def candidates():
for node in nodes:
# print "node is {}\n".format(node)
#node, say, ((0, 3),"face")
if list(nx.non_neighbors(component, node)) != []:
for each_non_neighbor in nx.non_neighbors(component, node):
candidate_nodes = [node]
if each_non_neighbor[0][0] == node[0][1]:
# print "each_non_neighbor is {}\n".format(each_non_neighbor)
#boo is one of the non_neighbors of "face"
candidate_nodes.append(search(component, [each_non_neighbor], each_non_neighbor, flag=''))
#booking, no further non_neighbors, so will return a node itself
#boo, has two non_neighbors -- "king" and "girl", will return the
yield candidate_nodes
#yield (score, [list of nodes])
else:
# print "NO NEIGHBOR WORD\n"
candidate_nodes = [node]
yield candidate_nodes
def test_non_neighbors(self):
graph = nx.complete_graph(100)
pop = random.sample(list(graph), 1)
nbors = list(nx.non_neighbors(graph, pop[0]))
# should be all the other vertices in the graph
assert_equal(len(nbors), 0)
graph = nx.path_graph(100)
node = random.sample(list(graph), 1)[0]
nbors = list(nx.non_neighbors(graph, node))
# should be all the other vertices in the graph
if node != 0 and node != 99:
assert_equal(len(nbors), 97)
else:
assert_equal(len(nbors), 98)
# create a star graph with 99 outer nodes
graph = nx.star_graph(99)
nbors = list(nx.non_neighbors(graph, 0))
assert_equal(len(nbors), 0)
# disconnected graph
graph = nx.Graph()
graph.add_nodes_from(range(10))
nbors = list(nx.non_neighbors(graph, 0))
assert_equal(len(nbors), 9)
def nuevo_enlace2(i): #Se selecciona un nodo y se le conecta a otro cercano. Se perturba la posición del primero.
global g, delta_omega, b, delta_c
max_intentos = 1000
exito = False
n_nodes = len(g.nodes())
n_enlaces = len(g.edges())
max_enalces = 0.5 * n_nodes * (n_nodes - 1.0)
x0=g.node[i]['x']
y0=g.node[i]['y']
next_neighbors=[] #J: primero busco los 2º vecinos
for ii in nx.neighbors(g,i):
for nnb in nx.neighbors(g,ii):
#print('i=',i,'ii=',ii)
next_neighbors.append(nnb) #J: Solo consideramos enlaces con los 2º vecinos
#print('next_neigh=',next_neighbors)
if (n_enlaces < max_enalces) and (len(next_neighbors)>0):
#neighbs = nx.neighbors(g,i)
intentos = 0
while (exito != True) and (intentos<max_intentos):
intentos += 1 #J: Hay que dejar siempre una vía de escape en los while
#i = rd.choice(g.nodes()) #El agente se elige en el update2()
#rad = pareto.rvs(b, size=1) #Generate random numbers form a pareto density distribution b/(x^(1+b))
#rad = rad[0] #El comando anterior genera una lista con 1 elemento, que extraemos aquí
rad=rad0 # QUITAMOS vecindad con distribución de Pareto. Ahora es FIJA. JMP 19/01/18
#candidates0 = [nb for nb in g.nodes() if ( ((g.node[nb]['x']-x0)**2 + (g.node[nb]['y']-y0)**2) < rad**2) and (nb != i) ]
candidates0 = [nb for nb in next_neighbors if ( ((g.node[nb]['x']-x0)**2 + (g.node[nb]['y']-y0)**2) < rad**2) and (nb != i) ]
candidates = [nb for nb in candidates0 if (nb in nx.non_neighbors(g,i))] #J: antes de elegir vecino comprueba que no tiene enlace
n_candidates = len(candidates) #se limita por los de su especie y la otra
#print('i:',i,'n_candidates= ',n_candidates)
if n_candidates > 0:
j=rd.choice(candidates)
if j in nx.non_neighbors(g,i): #nx.non_neighbors(g,i) proporciona la lista de no-vecinos de i
g.add_edge(i, j)
exito = True
#angulo = rd.random()*2*math.pi
#modulo = rd.random()*delta_c
#g.node[i]['x'] += modulo*np.cos(angulo)
#g.node[i]['y'] += modulo*np.sin(angulo)
return i #devuelve el valor del nodo al que se ha conectado el nodo recien creado
else: #Si el grafo es completo, añadimos un nuevo nodo
#i = rd.choice(g.nodes()) #J: Si no puede añadir enlace VUELVE
#nuevo_nodo2(i)
return i
def populate_query_set(gr,query_nodes):
G = gr.get_nx_graph()
#remove nodes from their own neighbourhood set
G.remove_edges_from(nx.selfloop_edges(G))
#code to limit non-edge set to 2-path reachable nodes
G_adj_mat = nx.to_numpy_matrix(G)
#A^2+A has non-zero entries for 1-len and 2-len reachable nodes for adjacency matrix A
G_mod = nx.from_numpy_matrix(G_adj_mat*G_adj_mat + G_adj_mat)
query_full_set = {}
for q_node in query_nodes:
query_full_set[q_node] = {}
query_full_set[q_node]['Nbr'] = list(nx.neighbors(G,q_node))
query_full_set[q_node]['NonNbr'] = list(set(nx.non_neighbors(G,q_node))\
-set(nx.non_neighbors(G_mod,q_node)))
#assert 'Nbr' and 'NonNbr' for all q_nodes are complements wrt 2-len neighbourhood and neither contain q_node
assert( all([ \
(set(query_full_set[q_node]['Nbr']).intersection(query_full_set[q_node]['NonNbr']) == set() ) \
and (len(query_full_set[q_node]['Nbr']) + len(query_full_set[q_node]['NonNbr'])==len(list(nx.neighbors(G_mod,q_node)))-1) \
and (q_node not in set(query_full_set[q_node]['Nbr']).union(query_full_set[q_node]['NonNbr'])) \
for q_node in query_nodes]) \
==True)
return query_full_set
def test_non_neighbors(self):
graph = nx.complete_graph(100)
pop = random.sample(list(graph), 1)
nbors = list(nx.non_neighbors(graph, pop[0]))
# should be all the other vertices in the graph
assert_equal(len(nbors), 0)
graph = nx.path_graph(100)
node = random.sample(list(graph), 1)[0]
nbors = list(nx.non_neighbors(graph, node))
# should be all the other vertices in the graph
if node != 0 and node != 99:
assert_equal(len(nbors), 97)
else:
assert_equal(len(nbors), 98)
# create a star graph with 99 outer nodes
graph = nx.star_graph(99)
nbors = list(nx.non_neighbors(graph, 0))
assert_equal(len(nbors), 0)
# disconnected graph
graph = nx.Graph()
graph.add_nodes_from(range(10))
nbors = list(nx.non_neighbors(graph, 0))
assert_equal(len(nbors), 9)
def candidates():
for node in nodes:
# print "working on node: {}".format(node)
if list(nx.non_neighbors(component, node)) != []:
for each_non_neighbor in nx.non_neighbors(component, node):
candidate_nodes = [node]
# print "candidate_nodes are {}".format(candidate_nodes)
# print "and the each_non_neighbor is {}".format(each_non_neighbor)
if each_non_neighbor[0][0] == node[0][1]:
# print "position adhered each_non_neighbor found: {0} of node {1}\n".format(each_non_neighbor,node)
candidate_nodes.append(
search(
component,
nodes=[each_non_neighbor], # DP remembers this list
node=each_non_neighbor,
flag="",
)
)
yield candidate_nodes
else:
# NO NEIGHBOR WORD
candidate_nodes = [node]
yield candidate_nodes
def search(component, nodes=nodes, node=nodes[0], flag='init'):
if not nx.non_neighbors(component, node) and flag != 'init':
# print "no neighbor found for node: {}".format([node])
return node
elif nx.non_neighbors(component, node) and flag != 'init':
#only look at word forwad
flag = "HASNOT"
for each in nx.non_neighbors(component, node):
if each[0][0] > node[0][0]:
#if non_neighbor has forward neighbors
#keep the flag
flag = "HAS"
break
else:
#all non_neighbors are in front of the node
pass
if flag == "HASNOT":
# print "no forward neighbor folloing node: {}".format([node])
#means no forward neighbor found
return node
else:
#means it has non_neighbor following it
pass
def candidates():
for node in nodes:
# print "working on node: {}".format(node)
if list(nx.non_neighbors(component, node)) != []:
for each_non_neighbor in nx.non_neighbors(component, node):
candidate_nodes = [node]
# print "candidate_nodes are {}".format(candidate_nodes)
# print "and the each_non_neighbor is {}".format(each_non_neighbor)
if each_non_neighbor[0][0] == node[0][1]:
# print "position adhered each_non_neighbor found: {0} of node {1}\n".format(each_non_neighbor,node)
candidate_nodes.append(
search(
component, nodes=[each_non_neighbor], #DP remembers this list
node=each_non_neighbor, flag=''
)
)
yield candidate_nodes
else:
#NO NEIGHBOR WORD
candidate_nodes = [node]
yield candidate_nodes
tmp_lst = list(candidates())
s = []
for i in tmp_lst:
if i not in s:
s.append(i)
return s
def search(component, nodes=nodes, node=nodes[0], flag='init'):
if not nx.non_neighbors(component, node) and flag != 'init':
print "no neighbor returned: {}".format([node])
return node
elif nx.non_neighbors(component, node) and flag != 'init':
#only look at word forwad
flag = "HASNOT"
for each in nx.non_neighbors(component, node):
if each[0][0] > node[0][0]:
#if non_neighbor has forward neighbors
#keep the flag
flag = "HAS"
break
else:
#all non_neighbors are in front of the node
pass
if flag == "HASNOT":
print "no forward neighbor returned: {}".format([node])
return node
else:
#means it has non_neighbor following it
pass
def candidates():
for node in nodes:
print "node is {}\n".format(node)
#node, say, ((0, 3),"face")
if list(nx.non_neighbors(component, node)) != []:
for each_non_neighbor in nx.non_neighbors(
component, node):
candidate_nodes = [node]
if each_non_neighbor[0][0] > node[0][0]:
print "each_non_neighbor is {}\n".format(
each_non_neighbor)
#boo is one of the non_neighbors of "face"
candidate_nodes.append(
search(component, [each_non_neighbor],
each_non_neighbor,
flag=''))
#booking, no further non_neighbors, so will return a node itself
#boo, has two non_neighbors -- "king" and "girl", will return the
yield candidate_nodes
#yield (score, [list of nodes])
else:
print "HHHHEEEERRRREEEE\n"
candidate_nodes = [node]
yield candidate_nodes
return list(candidates())
def results():
sPageTitle = 'Results page - MyWeddingSeatingPlanner.com'
sDescription = 'Your seating plan for your wedding as generated by us.'
objMeta = {
'googlebot': 'index,follow,snippet,archive',
'description': sDescription,
'keywords': 'seating plans, wedding, guests, seats',
'publisher': 'BahamSoft Ltd',
'og:title': sPageTitle,
'og:description': sDescription
}
# numguests = int(session['config']['numguest'])
num_tables = int(session['config']['numtables'])
table_capacity = int(session['config']['numguestspertable'])
min_known_neighbors = 1
# min_known_neighbors = int(session['config']['minguestpertable'])
names = [i['name'] for i in session['guestlist']]
# ensure that nodes with the same acquintance are connected with weight 1
# this operation should happen just before passing the graph to the final computation
acqlookup = {guest['id']: guest['acq'] for guest in session['guestlist']}
for node in session['graph'].nodes():
#print('node %s is in the graph acq is %s' % (node, acqlookup[node]))
for i in nx.non_neighbors(session['graph'], node):
#print('acq of node %d is %s vs acq of node %d is %s' % (node, acqlookup[node], i, acqlookup[i]))
if acqlookup[node] and acqlookup[node] == acqlookup[i]:
session['graph'].add_edge(node, i, weight=1)
# check the network connectivity, if it equal to 0 it means that the customer didn't specify
# any guest acquintance, so we randomly connect the nodes for the solver to work correctly
if session['graph'].number_of_edges() == session['graph'].number_of_nodes():
# we need to randomly assign weight to nodes
print('randomly assigning weights as there are not enough edges')
for node in session['graph'].nodes():
for i in nx.non_neighbors(session['graph'], node):
session['graph'].add_edge(node, i, weight=random.choice([0, 1, 50]))
C = nx.adjacency_matrix(session['graph'],
nodelist=range(1, session['graph'].number_of_nodes() + 1)).todense().tolist()
#print('matrix: ', C)
solution = WeddingChartPrinter.solve_with_discrete_model(num_tables, table_capacity, min_known_neighbors, C, names)
solutionrow = SeatingPlan(session['user_id'], solution, session)
db.session.add(solutionrow)
db.session.commit()
# stripe payment data
stripejs, stripeobj = StripeWrapper.generatePaymentData(session['user_id'], stripekey, request.url_root)
sol = dict(list(solution.items())[:len(solution)//2])
return render_template('results.html', meta=objMeta,
title=sPageTitle, seating=sol, extrajs=stripejs, stripeobj=stripeobj)
def ramsey_R2(graph):
r"""Approximately computes the Ramsey number `R(2;s,t)` for graph.
Parameters
----------
graph : NetworkX graph
Undirected graph
Returns
-------
max_pair : (set, set) tuple
Maximum clique, Maximum independent set.
"""
if not graph:
return (set([]), set([]))
node = next(graph.nodes_iter())
nbrs = nx.all_neighbors(graph, node)
nnbrs = nx.non_neighbors(graph, node)
c_1, i_1 = ramsey_R2(graph.subgraph(nbrs))
c_2, i_2 = ramsey_R2(graph.subgraph(nnbrs))
c_1.add(node)
i_2.add(node)
return (max([c_1, c_2]), max([i_1, i_2]))
def ramsey_R2(G):
r"""Compute the largest clique and largest independent set in `G`.
This can be used to estimate bounds for the 2-color
Ramsey number `R(2;s,t)` for `G`.
This is a recursive implementation which could run into trouble
for large recursions. Note that self-loop edges are ignored.
Parameters
----------
G : NetworkX graph
Undirected graph
Returns
-------
max_pair : (set, set) tuple
Maximum clique, Maximum independent set.
"""
if not G:
return set(), set()
node = arbitrary_element(G)
nbrs = (nbr for nbr in nx.all_neighbors(G, node) if nbr != node)
nnbrs = nx.non_neighbors(G, node)
c_1, i_1 = ramsey_R2(G.subgraph(nbrs).copy())
c_2, i_2 = ramsey_R2(G.subgraph(nnbrs).copy())
c_1.add(node)
i_2.add(node)
# Choose the larger of the two cliques and the larger of the two
# independent sets, according to cardinality.
return max(c_1, c_2, key=len), max(i_1, i_2, key=len)
def calculate_probabilities(graph, mode='undirected unweighted') :
probabilities_to_add_edge = defaultdict(dict)
number_of_shortest_paths = {}
if mode == 'directed':
shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(graph))
for node in graph.nodes() :
number_of_shortest_paths[node] = BFS_With_Shortest_Paths(graph, node)[2]
for node in graph.nodes() :
for second_node in nx.non_neighbors(graph, node):
if mode == 'undirected unweighted' :
coomon_neighbors_size = len(list(nx.common_neighbors(graph, node, second_node)))
probabilities_to_add_edge[node][second_node] = 1 - pow(float(0.97), coomon_neighbors_size)
elif mode == 'undirected weighted' :
m = 0
n = 0
for neighbor in nx.common_neighbors(graph, node, second_node) :
if graph[node][neighbor]['weight'] == 'strong' :
m += 1
else:
n += 1
probabilities_to_add_edge[node][second_node] = 1 - (pow(float(0.96), m) * pow(float(0.98),n))
elif mode == 'directed':
if second_node in shortest_path_lengths[node]:
L = shortest_path_lengths[node][second_node]
if L <= 4:
M = number_of_shortest_paths[node][second_node]
probabilities_to_add_edge[node][second_node] = min(1, M / (math.pow(5, L)))
return probabilities_to_add_edge
def khren(G):
result_s = []
result_d = []
passed_set = []
list_neighbrs = {}
for v in G.nodes:
list_neighbrs.update({v: set(nx.neighbors(G, v))})
for u in G.nodes:
passed_set.append(u)
for v in nx.non_neighbors(G, u):
if not v in passed_set:
cmn_nmbr = len(list_neighbrs[u] & list_neighbrs[v])
# dist = nx.shortest_path_length(G,u,v)
# if dist == 2:
# cmn_nmbr = G.distance(u,v)
if G.nodes[u]["ground_label"] == G.nodes[v]['ground_label']:
result_s.append(cmn_nmbr)
else:
result_d.append(cmn_nmbr)
max_s = max(result_s)
max_d = max(result_d)
print(max_s, max_d)
return (result_s, result_d)
def ramsey_R2(G):
r"""Approximately computes the Ramsey number `R(2;s,t)` for graph.
Parameters
----------
G : NetworkX graph
Undirected graph
Returns
-------
max_pair : (set, set) tuple
Maximum clique, Maximum independent set.
"""
if not G:
return set(), set()
node = arbitrary_element(G)
nbrs = nx.all_neighbors(G, node)
nnbrs = nx.non_neighbors(G, node)
c_1, i_1 = ramsey_R2(G.subgraph(nbrs))
c_2, i_2 = ramsey_R2(G.subgraph(nnbrs))
c_1.add(node)
i_2.add(node)
# Choose the larger of the two cliques and the larger of the two
# independent sets, according to cardinality.
return max(c_1, c_2, key=len), max(i_1, i_2, key=len)
def has_missing_edges(self, threshold: float = 0.0) -> int:
"""
Returns the maximal number of missing edges in the model according to the collected interventional
data. The maximum number is returned because the exact number cannot be determined with an intervention
on a single variable.
:param threshold:
:return:
Example
---------
Let the ground truth causal model be A -> B -> C and the causal model of the agent A B -> C (missing
edge between A and B). This method will return 2. This is because the edge between A and B induces an indirect
effect of A on C which cannot be distilled from a direct effect that could be present from A to C.
The collected interventional data with the intervention only on one variable cannot distinguish between
A -> B -> C and A -> B -> C, hence a maximum of 2 edges are missing.
| ^
- - - - - |
Important: Once there is any path from A to C, no edge is considered to be missing.
e.g. applied to the model A -> B -> C this method returns 0
e.g. applied to the model A -> C <- B this method returns 1 as the edge A -> B is missing.
"""
missing_edges = 0
# check which causal relationships are missing in the graph
for n in self.causal_model.nodes:
# iterate over all nodes that do not already have an edge from n
for nn in nx.non_neighbors(self.causal_model, n):
current_edge = (str(n), str(nn))
if self.edge_is_missing(current_edge, threshold):
missing_edges += 1
return missing_edges
def rewire(M,p):
R = nx.Graph(M)
rewireSet = [i for i in nx.edges_iter(R) if random.random() < p]
R.remove_edges_from(rewireSet)
for i in rewireSet:
R.add_edge(i[0],random.sample([k for k in nx.non_neighbors(R,i[0])],1)[0])
return R
def ramsey_R2(G):
r"""Approximately computes the Ramsey number `R(2;s,t)` for graph.
Parameters
----------
G : NetworkX graph
Undirected graph
Returns
-------
max_pair : (set, set) tuple
Maximum clique, Maximum independent set.
"""
if not G:
return (set([]), set([]))
node = next(G.nodes_iter())
nbrs = nx.all_neighbors(G, node)
nnbrs = nx.non_neighbors(G, node)
c_1, i_1 = ramsey_R2(G.subgraph(nbrs))
c_2, i_2 = ramsey_R2(G.subgraph(nnbrs))
c_1.add(node)
i_2.add(node)
return (max([c_1, c_2]), max([i_1, i_2]))
def __genGwMesh(self):
"""Generates the multiple domains GW mesh
:return: networkx instance"""
# Calc number of mesh links
gwMesh = nx.cycle_graph(self.__domains)
_ = self.__getNextIds(self.__domains)
possibleLinks = itertools.combinations(range(self.__domains), 2)
possibleLinks = len(list(possibleLinks)) - self.__domains
numLinks = math.floor(self.__meshDegree * possibleLinks)
# Add randomly mesh links
linked, i = 0, 0
random.seed(datetime.now())
while linked < numLinks:
candidates = list(nx.non_neighbors(gwMesh, i))
if len(candidates) > 0:
candid = random.randint(0, len(candidates) - 1)
gwMesh.add_edge(i,
candidates[candid],
res=self.__genMeshLnkRes(),
meshLink='True')
linked += 1
i = (i + 1) % self.__domains
# Add mesh attribute to original cycle edges
if self.__domains > 1: # Possible to have only have 1 domain
for gw in range(self.__domains):
nextGw = 0 if gw == self.__domains - 1 else gw + 1
gwMesh[gw][nextGw]['meshLink'] = 'True'
gwMesh[gw][nextGw]['res'] = self.__genMeshLnkRes()
return gwMesh
def connect_leafs(G, leafs):
"""Some graph generators make nodes with no neighbors. This fixes that."""
random.seed(
1
) # This is a side application, so I'm okay using different seed than generator
for leaf in leafs:
G.add_edge(leaf, random.choice(list(nx.non_neighbors(G, leaf))))
def ramsey_R2(G):
"""Approximately computes the Ramsey number `R(2;s,t)` for graph.
Parameters
----------
G : NetworkX graph
Undirected graph
Returns
-------
max_pair : (set, set) tuple
Maximum clique, Maximum independent set.
"""
if not G:
return set(), set()
node = arbitrary_element(G)
nbrs = set(nx.all_neighbors(G, node))
nbrs.discard(node)
nnbrs = nx.non_neighbors(G, node)
c_1, i_1 = ramsey_R2(G.subgraph(nbrs).copy())
c_2, i_2 = ramsey_R2(G.subgraph(nnbrs).copy())
c_1.add(node)
i_2.add(node)
# Choose the larger of the two cliques and the larger of the two
# independent sets, according to cardinality.
return max(c_1, c_2, key=len), max(i_1, i_2, key=len)
def get_balance_coefficient(nx_G, X):
cos_sims = cosine_similarity(X, X)
print("Similarity Computing Finished!")
rate = 0
isolate_count = 0
for node in nx_G.nodes():
neis = list(nx.neighbors(nx_G, node))
neis_of_neis = []
for nei in neis:
neis_of_neis.extend(list(nx.neighbors(nx_G, nei)))
neis.extend(neis_of_neis)
neis = list(set(neis))
neis_sims = cos_sims[node, neis]
if len(neis_sims) == 0:
isolate_count = isolate_count + 1
continue
avg_of_nei_sims = np.min(neis_sims)
#avg_of_nei_sims = neis_sims.median()
non_neis = set(nx.non_neighbors(nx_G, node))
non_neis = non_neis - set(neis_of_neis)
non_neis = list(non_neis)
non_neis_sims = cos_sims[node, non_neis]
abnormals = np.where(non_neis_sims > avg_of_nei_sims)[0]
num_of_abnormals = abnormals.shape[0]
num_of_neis = len(neis)
rate += num_of_abnormals / len(non_neis)
return rate / (len(nx_G.nodes()) - isolate_count)
def gen_test_edge_wrt_changes(graph_t0, graph_t1, seed=None):
''' input: two networkx graphs
generate **changed** testing edges for link prediction task
currently, we only consider pos_neg_ratio = 1.0
return: pos_edges_with_label [(node1, node2, 1), (), ...]
neg_edges_with_label [(node3, node4, 0), (), ...]
'''
G0 = graph_t0.copy()
G1 = graph_t1.copy(
) # use copy to avoid problem caused by G1.remove_node(node)
edge_add = edge_s1_minus_s0(s1=set(G1.edges()), s0=set(G0.edges()))
edge_del = edge_s1_minus_s0(s1=set(G0.edges()), s0=set(G1.edges()))
unseen_nodes = set(G1.nodes()) - set(G0.nodes())
for node in unseen_nodes: # to avoid unseen nodes while testing
G1.remove_node(node)
edge_add_unseen_node = [] # to avoid unseen nodes while testing
#print('len(edge_add)', len(edge_add))
for node in unseen_nodes:
for edge in edge_add:
if node in edge:
edge_add_unseen_node.append(edge)
edge_add = edge_add - set(edge_add_unseen_node)
#print('len(edge_add)', len(edge_add))
neg_edges_with_label = [list(item + (0, )) for item in edge_del]
pos_edges_with_label = [list(item + (1, )) for item in edge_add]
random.seed(seed)
all_nodes = list(G0.nodes())
if len(edge_add) > len(edge_del):
num = len(edge_add) - len(edge_del)
start_nodes = np.random.choice(all_nodes, num, replace=True)
i = 0
for start_node in start_nodes:
non_nbrs = list(nx.non_neighbors(G0, start_node))
non_nbr = random.sample(non_nbrs, 1).pop()
non_edge = (start_node, non_nbr)
if non_edge not in edge_del:
neg_edges_with_label.append(list(non_edge + (0, )))
i += 1
if i >= num:
break
elif len(edge_add) < len(edge_del):
num = len(edge_del) - len(edge_add)
i = 0
for edge in nx.edges(G1):
if edge not in edge_add:
pos_edges_with_label.append(list(edge + (1, )))
i += 1
if i >= num:
break
else: # len(edge_add) == len(edge_del)
pass
print('---- len(pos_edges_with_label), len(neg_edges_with_label)',
len(pos_edges_with_label), len(neg_edges_with_label))
return pos_edges_with_label, neg_edges_with_label
def add_and_remove_edges(G,
p_new_connection,
p_remove_connection,
num_add=10,
num_remove=10):
'''
for each node,
add a new connection to random other node, with prob p_new_connection,
remove a connection, with prob p_remove_connection
operates on G in-place
'''
new_edges = []
rem_edges = []
count_rm = 0
count_add = 0
for node in G.nodes():
# find the other nodes this one is connected to
# connected = [to for (fr, to) in G.edges(node)]
connected = G.neighbors(node)
# and find the remainder of nodes, which are candidates for new edges
# unconnected = [n for n in G.nodes() if not n in connected]
unconnected = [n for n in nx.non_neighbors(G, node)]
# probabilistically add a random edge
if len(unconnected
) and count_add <= num_add: # only try if new edge is possible
if random.random() < p_new_connection:
count_add += 1
new = random.choice(unconnected)
G.add_edge(node, new)
new_edges.append((node, new))
# book-keeping, in case both add and remove done in same cycle
# unconnected.remove(new)
# connected.append(new)
if count_add % 1000 == 0:
print("\t{0}-th new edge:\t {1} -- {2}".format(
count_add, node, new))
# probabilistically remove a random edge
if len(
connected
) and count_rm <= num_remove: # only try if an edge exists to remove
if random.random() < p_remove_connection:
count_rm += 1
remove = random.choice(connected)
G.remove_edge(node, remove)
rem_edges.append((node, remove))
# book-keeping, in case lists are important later?
# connected.remove(remove)
# unconnected.append(remove)
if count_rm % 1000 == 0:
print("\t{0}-th edge removed:\t {1} -- {2}".format(
count_rm, node, remove))
if count_rm > num_remove and count_add > num_add:
break
return rem_edges, new_edges
def rewire(M, p):
R = nx.Graph(M)
rewireSet = [i for i in nx.edges_iter(R) if random.random() < p]
R.remove_edges_from(rewireSet)
for i in rewireSet:
R.add_edge(i[0],
random.sample([k for k in nx.non_neighbors(R, i[0])], 1)[0])
return R
def scramble(M,p):
R = nx.Graph(M)
removeSet = [i for i in nx.edges_iter(R) if random.random() < p]
R.remove_edges_from(removeSet)
nodes = R.nodes()
addFromNodes = [random.sample(nodes,1)[0] for i in removeSet]
for node in addFromNodes:
R.add_edge(node,random.sample([k for k in nx.non_neighbors(R,node)],1)[0])
return R
def get_set_complementary_neighborhood(G, A):
compl_neighborhood = []
for set_node in A:
compl_neighborhood.append(list(nx.non_neighbors(G, set_node)))
if not compl_neighborhood:
return []
else:
intersection = set.intersection(*map(set, compl_neighborhood))
return list(intersection)
def processGraph(G, nx, num, max_r):
nnei = []
nei = []
for i in nx.non_neighbors(G, 0):
nnei.append(i)
tobrk = False
while nnei:
for l in range(0, num):
if tobrk:
tobrk = False
break
nodes = G.nodes(data=True)
for i in nx.all_neighbors(G, l):
nei.append(i) #neighbors of l
for i in nx.non_neighbors(G, l):
nnei.append(i) # non-neighbors of l
for t in nei:
for i in nx.all_neighbors(G, t):
nei.append(i)
nei = list(set(nei))
nnei = list(set(nnei) - set(nei)) ## these are unconnected
##Generate random positions and calculate them again
for i in nnei:
for e in G.edges():
if i in e:
G.remove_edge(*e)
G.add_node(
i,
{'pos': [randint(0, max_x * max_r) for l in range(0, 2)]})
nodes = G.nodes(data=True)
u, du = nodes[i]
pu = du['pos']
for v, dv in nodes:
pv = dv['pos']
d = sum(
((int(a) - int(b))**2 for a, b in zip(pu, pv)))**(0.5)
if int(d) <= int(max_r) and int(
d) > 5: ## to not be on the same position
G.add_edge(u, v)
tobrk = True
##should break to the while so it will revise the network
return G
def scramble(M, p):
R = nx.Graph(M)
removeSet = [i for i in nx.edges_iter(R) if random.random() < p]
R.remove_edges_from(removeSet)
nodes = R.nodes()
addFromNodes = [random.sample(nodes, 1)[0] for i in removeSet]
for node in addFromNodes:
R.add_edge(node,
random.sample([k for k in nx.non_neighbors(R, node)], 1)[0])
return R
def ramsey2(G):
if len(list(G.nodes())) == 0:
return (nx.Graph(), nx.Graph())
else:
nodes = list(G.nodes())
v = nodes[random.randint(0, len(nodes) - 1)]
# all_neighbors = copy.deepcopy(G)
# non_neighbors = copy.deepcopy(G)
all_neighbors_list = []
non_neighbors_list = []
# for neighbor in nx.all_neighbors(G,v):
# all_neighbors_list.append(neighbor)
# all_neighbors_list.append(v)
# for neighbor in nx.non_neighbors(G,v):
# non_neighbors_list.append(neighbor)
# non_neighbors_list.append(v)
# Non-neighbor graph
all_neighbors = G.subgraph(list(nx.all_neighbors(G, v)))
non_neighbors = G.subgraph(list(nx.non_neighbors(G, v)))
# print(v)
# print((list(nx.all_neighbors(G,v)).append(v)))
# print(all_neighbors.nodes())
# print(non_neighbors.nodes())
# print(G.subgraph(list(nx.all_neighbors(G,v))).nodes())
# print(all_neighbors.nodes())
# print(list(nx.all_neighbors(G,v)).append(v))
# Neighbor graph
# for nonneighbor in nx.non_neighbors(G,v):
# all_neighbors.remove_node(nonneighbor)
# all_neighbors.remove_node(v)
c1, i1 = ramsey2(all_neighbors)
c2, i2 = ramsey2(non_neighbors)
if len(list(c1.nodes())) + 1 >= len(list(c2.nodes())):
c1.add_node(v)
c = copy.deepcopy(c1)
else:
c = copy.deepcopy(c2)
if len(list(i1.nodes())) >= len(list(i2.nodes())) + 1:
i = copy.deepcopy(i1)
else:
i2.add_node(v)
i = copy.deepcopy(i2)
return (c, i)
def rule_1(self, edge_types):
any_changed = False
for x in nx.nodes(self.skeleton):
for z in nx.non_neighbors(self.skeleton, x):
for y in nx.common_neighbors(self.skeleton, x, z):
if edge_types[(x, y)] != ArrowType.ARROW:
continue
if edge_types[(z, y)] != ArrowType.CIRCLE:
continue
edge_types[(z, y)] = ArrowType.NONE
edge_types[(y, z)] = ArrowType.ARROW
any_changed = True
return any_changed
def pc_rule_1(self, edge_types):
any_changed = False
for a in nx.nodes(self.skeleton):
for c in nx.non_neighbors(self.skeleton, a):
for b in nx.common_neighbors(self.skeleton, a, c):
if edge_types[(a, b)] != ArrowType.ARROW:
continue
if edge_types[(c, b)] != ArrowType.CIRCLE:
continue
edge_types[(b, c)] = ArrowType.ARROW
edge_types[(c, b)] = ArrowType.NONE
any_changed = True
return any_changed
def ramsey_R2(graph):
if not graph:
return (set([]), set([]))
node = next(graph.nodes_iter())
nbrs = nx.all_neighbors(graph, node)
nnbrs = nx.non_neighbors(graph, node)
c_1, i_1 = ramsey_R2(graph.subgraph(nbrs))
c_2, i_2 = ramsey_R2(graph.subgraph(nnbrs))
c_1.add(node)
i_2.add(node)
return (max([c_1, c_2]), max([i_1, i_2]))
def ramsey_R2(graph):
if not graph:
return (set([]), set([]))
node = next(graph.nodes_iter())
nbrs = nx.all_neighbors(graph, node)
nnbrs = nx.non_neighbors(graph, node)
c_1, i_1 = ramsey_R2(graph.subgraph(nbrs))
c_2, i_2 = ramsey_R2(graph.subgraph(nnbrs))
c_1.add(node)
i_2.add(node)
return (max([c_1, c_2]), max([i_1, i_2]))
def probabilities_for_new_edges(graph) : shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(graph)) number_of_shortest_paths = defaultdict(dict) for node in graph.nodes() : number_of_shortest_paths[node] = BFS_With_Shortest_Paths(graph, node)[2] probabilities_to_add_edge = defaultdict(dict) for node in graph.nodes() : for second_node in nx.non_neighbors(graph, node): if second_node in shortest_path_lengths[node]: L = shortest_path_lengths[node][second_node] if L <= 4: M = number_of_shortest_paths[node][second_node] probabilities_to_add_edge[node][second_node] = min(1, (M / (math.pow(10, 1.05 * L))) * get_average_rating_neighbors(graph, node)) return probabilities_to_add_edge
def candidates():
for node in nodes:
# print "working on node: {}".format(node)
if list(nx.non_neighbors(component, node)) != []:
for each_non_neighbor in nx.non_neighbors(component, node):
candidate_nodes = [node]
# print "candidate_nodes are {}".format(candidate_nodes)
# print "and the each_non_neighbor is {}".format(each_non_neighbor)
if each_non_neighbor[0][0] == node[0][1]:
# print "position adhered each_non_neighbor found: {0} of node {1}\n".format(each_non_neighbor,node)
candidate_nodes.append(
search(
component, nodes=[each_non_neighbor], #DP remembers this list
node=each_non_neighbor, flag=''
)
)
yield candidate_nodes
else:
#NO NEIGHBOR WORD
candidate_nodes = [node]
yield candidate_nodes
def ws(n, m, p):
"""
This function call the ring() function to make a basic ring and then
rewires each link with probability p and also prints the total number of
links and the number of rewired links.
Note self-loops are not allowed when rewiring (check that you do not rewire
the end of a link to the node at its other end!)
Parameters
----------
n : int
Number of nodes
m : int
Number of neighbors to connect left and right
p : float
Rewiring probability
Returns
-------
network : graph
The Watts-Strogatz small-world network
"""
network = ring(n, m)
edges = network.edges()
rewired_num = 0 # tracks the number of rewired links
total_num = 0 # tracks the total number of links in the network
for e in edges:
if np.random.rand() < p:
i,j = e
NN=nx.non_neighbors(network,i)
network.remove_edge(i,j)
network.add_edge(i,random.choice(list(NN)))
rewired_num += 1
total_num = network.number_of_edges()
# You should rewire each edge if: numpy.random.rand() < p
# Also, avoid duplicate links (rewiring to a neighbor of the other node)
# as well as self-links (rewiring one endpoint to the other)
# You might find these useful: random.choice and nx.non_neighbors
# The latter yields an iterator: NN=nx.non_neighbors(G,i) lists all nodes
# that are not connected to i (and are not i)
# YOUR CODE HERE
#print total number of links in the graph and number of rewired links:
print("total number of links:")
print(total_num)
print("number of rewired links:")
print(rewired_num)
return network
def ramsey_R2(self, G):
if not G:
return set(), set()
node = self.arbitrary_element(G)
nbrs = nx.all_neighbors(G, node)
nnbrs = nx.non_neighbors(G, node)
c_1, i_1 = self.ramsey_R2(G.subgraph(nbrs).copy())
c_2, i_2 = self.ramsey_R2(G.subgraph(nnbrs).copy())
c_1.add(node)
i_2.add(node)
# Choose the larger of the two cliques and the larger of the two
# independent sets, according to cardinality.
return max(c_1, c_2, key=len), max(i_1, i_2, key=len)
def build_noise_list(agraph):
"""
Using the adjaceny graph, generate a list of 1000 pairs of non-adjacent images and words.
This will be added to the learning set to make sure our algorithm can distinguish between
words and images that should not be close.
"""
noise_list = []
for node in nodes(agraph):
for non_neighbor in nx.non_neighbors(agraph, node):
if node[type] != non_neight[type]:
noise_list.append((node, non_neighbor))
if len(noise_list) >= 1000:
break
if len(noise_list) >= 1000:
break
return noise_list
def all_node_cuts(G, k=None, flow_func=None):
r"""Returns all minimum k cutsets of an undirected graph G.
This implementation is based on Kanevsky's algorithm [1]_ for finding all
minimum-size node cut-sets of an undirected graph G; ie the set (or sets)
of nodes of cardinality equal to the node connectivity of G. Thus if
removed, would break G into two or more connected components.
Parameters
----------
G : NetworkX graph
Undirected graph
k : Integer
Node connectivity of the input graph. If k is None, then it is
computed. Default value: None.
flow_func : function
Function to perform the underlying flow computations. Default value
edmonds_karp. This function performs better in sparse graphs with
right tailed degree distributions. shortest_augmenting_path will
perform better in denser graphs.
Returns
-------
cuts : a generator of node cutsets
Each node cutset has cardinality equal to the node connectivity of
the input graph.
Examples
--------
>>> # A two-dimensional grid graph has 4 cutsets of cardinality 2
>>> G = nx.grid_2d_graph(5, 5)
>>> cutsets = list(nx.all_node_cuts(G))
>>> len(cutsets)
4
>>> all(2 == len(cutset) for cutset in cutsets)
True
>>> nx.node_connectivity(G)
2
Notes
-----
This implementation is based on the sequential algorithm for finding all
minimum-size separating vertex sets in a graph [1]_. The main idea is to
compute minimum cuts using local maximum flow computations among a set
of nodes of highest degree and all other non-adjacent nodes in the Graph.
Once we find a minimum cut, we add an edge between the high degree
node and the target node of the local maximum flow computation to make
sure that we will not find that minimum cut again.
See also
--------
node_connectivity
edmonds_karp
shortest_augmenting_path
References
----------
.. [1] Kanevsky, A. (1993). Finding all minimum-size separating vertex
sets in a graph. Networks 23(6), 533--541.
http://onlinelibrary.wiley.com/doi/10.1002/net.3230230604/abstract
"""
if not nx.is_connected(G):
raise nx.NetworkXError('Input graph is disconnected.')
# Address some corner cases first.
# For cycle graphs
if G.order() == G.size():
if all(2 == d for n, d in G.degree()):
seen = set()
for u in G:
for v in nx.non_neighbors(G, u):
if (u, v) not in seen and (v, u) not in seen:
yield {v, u}
seen.add((v, u))
return
# For complete Graphs
if nx.density(G) == 1:
for cut_set in combinations(G, len(G) - 1):
yield set(cut_set)
return
# Initialize data structures.
# Keep track of the cuts already computed so we do not repeat them.
seen = []
# Even-Tarjan reduction is what we call auxiliary digraph
# for node connectivity.
H = build_auxiliary_node_connectivity(G)
mapping = H.graph['mapping']
R = build_residual_network(H, 'capacity')
kwargs = dict(capacity='capacity', residual=R)
# Define default flow function
if flow_func is None:
flow_func = default_flow_func
if flow_func is shortest_augmenting_path:
kwargs['two_phase'] = True
# Begin the actual algorithm
# step 1: Find node connectivity k of G
if k is None:
k = nx.node_connectivity(G, flow_func=flow_func)
# step 2:
# Find k nodes with top degree, call it X:
X = {n for n, d in sorted(G.degree(), key=itemgetter(1), reverse=True)[:k]}
# Check if X is a k-node-cutset
if _is_separating_set(G, X):
seen.append(X)
yield X
for x in X:
# step 3: Compute local connectivity flow of x with all other
# non adjacent nodes in G
non_adjacent = set(G) - X - set(G[x])
for v in non_adjacent:
# step 4: compute maximum flow in an Even-Tarjan reduction H of G
# and step:5 build the associated residual network R
R = flow_func(H, '%sB' % mapping[x], '%sA' % mapping[v], **kwargs)
flow_value = R.graph['flow_value']
if flow_value == k:
# Remove saturated edges form the residual network
saturated_edges = [(u, w, d) for (u, w, d) in
R.edges(data=True)
if d['capacity'] == d['flow']]
R.remove_edges_from(saturated_edges)
# step 6: shrink the strongly connected components of
# residual flow network R and call it L
L = nx.condensation(R)
cmap = L.graph['mapping']
# step 7: Compute antichains of L; they map to closed sets in H
# Any edge in H that links a closed set is part of a cutset
for antichain in nx.antichains(L):
# Nodes in an antichain of the condensation graph of
# the residual network map to a closed set of nodes that
# define a node partition of the auxiliary digraph H.
S = {n for n, scc in cmap.items() if scc in antichain}
# Find the cutset that links the node partition (S,~S) in H
cutset = set()
for u in S:
cutset.update((u, w) for w in H[u] if w not in S)
# The edges in H that form the cutset are internal edges
# (ie edges that represent a node of the original graph G)
node_cut = {H.nodes[n]['id'] for edge in cutset for n in edge}
if len(node_cut) == k:
if node_cut not in seen:
yield node_cut
seen.append(node_cut)
# Add an edge (x, v) to make sure that we do not
# find this cutset again. This is equivalent
# of adding the edge in the input graph
# G.add_edge(x, v) and then regenerate H and R:
# Add edges to the auxiliary digraph.
H.add_edge('%sB' % mapping[x], '%sA' % mapping[v],
capacity=1)
H.add_edge('%sB' % mapping[v], '%sA' % mapping[x],
capacity=1)
# Add edges to the residual network.
R.add_edge('%sB' % mapping[x], '%sA' % mapping[v],
capacity=1)
R.add_edge('%sA' % mapping[v], '%sB' % mapping[x],
capacity=1)
break
# Add again the saturated edges to reuse the residual network
R.add_edges_from(saturated_edges)
def coloracion(grafo):
"""Devuelve la lista minima de colores a usar"""
nodosSinColorear = grafo.nodes()
colores = []
colorActual = (random(), random(), random())
coloresAsignados = {}
for i in nodosSinColorear:
if debug_true:
print "NodosSinColor[" + str(i) + "]:" + str(nodosSinColorear)
nodos_adyacentes = nx.all_neighbors(grafo, i)
nodos_no_adyacentes = nx.non_neighbors(grafo, i)
colores_adyacentes = []
colores_no_adyacentes = []
# Almacenamos todos los colores de los nodos adyacentes
for k in nodos_adyacentes:
if coloresAsignados.has_key(k):
colores_adyacentes.append(coloresAsignados[k])
# Almacenamos todos los colores de los nodos no adyacentes
for k in nodos_no_adyacentes:
if coloresAsignados.has_key(k):
colores_no_adyacentes.append(coloresAsignados[k])
# Volvemos a generar los iteradores para nodos adyacentes, ya que
# al iterar en los bucles de arriba se perdieron
nodos_adyacentes = nx.all_neighbors(grafo, i)
nodos_no_adyacentes = nx.non_neighbors(grafo, i)
if debug_true:
print "colores adyacentes a " + str(i) + str(colores_adyacentes)
print "colores no adyacentes a " + str(i) + str(colores_no_adyacentes)
aux = False
for j in nodos_adyacentes:
if debug_true:
print "j=" + str(j)
print "Color Actual=" + str(colorActual)
if not aux and colorActual not in colores_adyacentes:
aux = True
#pass
else:
aux = True
aux2 = False
# Recorremos los colores no adyacentes y comparamos
# el color con el adyacente, usaremos un color existente
# pero sin que coincida con alguno adyacente
if colores_no_adyacentes:
for t in colores_no_adyacentes:
if debug_true:
print t not in colores_adyacentes
if not aux2 and not t in colores_adyacentes:
aux2 = True
colorActual = t
if not aux2:
if debug_true:
print "Genero para " + str(i)
colorActual = (random(), random(), random())
coloresAsignados[i] = colorActual
colores.append(colorActual)
if (debug_true):
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(coloresAsignados)
for i in colores:
print i[0]
return colores
import networkx as nx # 关于图形的方法： nx.density(G) #返回图形的密度 nx.degree_histogram(G) #返回列表中每个值的频率 nx.info(G) #返回图形的摘要信息 ：节点数，边数，平均度 etc.. P=nx.create_empty_copy(G) #返回 移除边的 图形G的 副本 nx.is_directed(DG) #返回图形是否有向 #关于点的方法 nx.nodes(G) #以列表的形式返回所有节点 nx.number_of_nodes(G) #返回节点数 nx.all_neighbors(G,'tank') #以iterator的形式返回一个节点的所有邻居 nx.non_neighbors(G,'tank') #以iterator的形式返回一个节点的所有非邻居 nx.common_neighbors(G,'','') #以iterator的形式返回两个节点的公共邻居 nx.nodes_iter(G) #以iterator的形式返回所有节点 g = nx.compose(G,DG) #返会合并公共的node??? sorted(G.degree().values()) #关于边的方法 nx.edges(G) #以列表的形式返回所有的边 nx.number_of_edges(G) #返回边数 nx.non_edges(G) #以iterator的形式返回所有不存在的边 nx.edges_iter(G) #以iterator的形式返回所有边 #关于MultiDiGraph() G.successors(node) #返回一个节点的后继 G.predecessor(node) #返回一个节点的前任 G.number_of_edges(node,node) #返回两个节点间的边数 G.size() #返回图的边数
def available_nodes(G, cn, avl): for n in nx.non_neighbors(G, cn): if G.degree([n]).values()[0] < nodis[n]: avl.append(n) avl.sort() return len(avl)
