def test_maximal_by_cardinality(self):
"""Tests that the maximal clique is computed according to maximum
cardinality of the sets.
For more information, see pull request #1531.
"""
G = nx.complete_graph(5)
G.add_edge(4, 5)
clique = max_clique(G)
assert_greater(len(clique), 1)
G = nx.lollipop_graph(30, 2)
clique = max_clique(G)
assert_greater(len(clique), 2)
def test_maximal_by_cardinality(self):
"""Tests that the maximal clique is computed according to maximum
cardinality of the sets.
For more information, see pull request #1531.
"""
G = nx.complete_graph(5)
G.add_edge(4, 5)
clique = max_clique(G)
assert len(clique) > 1
G = nx.lollipop_graph(30, 2)
clique = max_clique(G)
assert len(clique) > 2
def Tabucol_opt(G, k, C_L=6, C_lambda=0.6, C_maxiter=100000, verbose=False):
'''Tabucol_opt provides the graph coloring with the smallest number of
colors'''
assert len(G) > 0
assert k > 0 and k <= len(G)
best_colors, best_niter = {}, 0
# compute length of max clique as number of colors cannot be less
length_max_clique = len(max_clique(G))
if k < length_max_clique:
print(
'Tabucol_opt cannot find a solution with less colors than length of maximum clique ',
length_max_clique)
else:
ncolors = k
while ncolors >= length_max_clique:
colors, niter = Tabucol(G, ncolors, C_L, C_lambda, C_maxiter)
if is_coloring_feasible(G, colors):
best_colors = dict(colors)
best_niter = niter
ncolors = max(colors.values())
if verbose:
print('Tabucol_opt found a solution with %d colors' %
(max(colors.values()) + 1))
else:
if not best_colors:
print(
'Tabucol_opt did not find a solution with %d colors' %
k)
break
return best_colors, best_niter
def only_max_clique(num_seeds, G):
max_cliq = max_clique(G)
print("GOT CLIQUE")
seeds = random.sample(max_cliq, min(num_seeds, len(max_cliq)))
print("GOT FIRST SAMPLE")
if len(seeds)<num_seeds:
seeds.extend(random.sample(max_cliq, num_seeds- len(seeds)))
# seeds = list(set(seeds))
print("GOT SECOND SAMPLE")
return seeds
def details(graph):
cliques_number = nx.graph_clique_number(graph)
print("Number of cliques in the graph %d:" % cliques_number)
clique = approximation.max_clique(graph)
print("Maximum clique of the graph is: %.2d" % len(clique))
print(clique)
shortest_path = nx.shortest_path(graph)
print("Shortest path: ", shortest_path)
try:
diameter = nx.diameter(graph)
print("Diameter of the graph: %d" % diameter)
except:
print("Graph is not connected!")
def only_max_clique(num_seeds, G):
max_cliq = max_clique(G)
print("GOT CLIQUE")
seeds = random.sample(max_cliq, min(num_seeds, len(max_cliq)))
print("GOT FIRST SAMPLE")
for i in range(num_seeds - len(seeds)):
node_degrees = G.degree()
sorted_node_degrees = np.array(sorted(node_degrees,key=itemgetter(1), reverse = True))
sorted_list = list(set(sorted_node_degrees[:num_seeds, 0])-set(seeds))
seeds.extend(sorted_list[i])
# seeds = list(set(seeds))
print("GOT SECOND SAMPLE")
return seeds
def preprocess_graph(self):
'''remove nodes with fewer degrees than the degree of a maximal
clique and from dominated sets'''
entering()
G = self.originalgraph.copy()
# compute maximum clique from networkx.algorithms.approximation
maxclique = max_clique(G)
len_maxclique = len(maxclique)
pruned_nodes = []
while True:
nnodes_at_start = len(G)
# iteration to remove nodes with degree < |max_clique|
partial_node_list = [
n for (n, deg) in G.degree()
if n not in maxclique and deg < len_maxclique
]
if partial_node_list:
G.remove_nodes_from(partial_node_list)
pruned_nodes.extend(partial_node_list)
# iteration to remove nodes from dominated neighborhoods
partial_node_list = []
for u in (u for u in G.nodes() if u not in maxclique):
for v in G.nodes():
if u == v or G.has_edge(u, v):
continue
if set(G[u]).issubset(set(G[v])):
partial_node_list.append(u)
break
if partial_node_list:
G.remove_nodes_from(partial_node_list)
pruned_nodes.extend(partial_node_list)
# repeat whenever there is improvement
if nnodes_at_start == len(G):
break
# update working graph and keep pruned nodes for post processing
self.graph.remove_nodes_from(pruned_nodes)
self.pruned_nodes = pruned_nodes[:]
if self.pruned_nodes:
print("pruned nodes are:", pruned_nodes)
self.graph = G.copy()
del G
else:
print("no nodes were pruned at pre-processing stage")
leaving()
def process(graph_file):
with open(graph_file, 'rt') as fileobj:
g = nx.Graph()
for line, text in enumerate(fileobj):
words = text.split()
assert len(words) == 2
if line == 0:
assert words[0] == 'keys'
num_keys = int(words[1])
vertices = range(num_keys)
g.add_nodes_from(vertices)
else:
v1 = int(words[0])
v2 = int(words[1])
assert v1 >= 0 and v1 < num_keys
assert v2 >= 0 and v2 < num_keys
g.add_edge(v1, v2)
print len(nx_alg.max_clique(g)), num_keys
def print_graph_features(self, graph):
res = {}
try:
print('diameter: ', nx.diameter(graph))
print('eccentricity: ', nx.eccentricity(graph))
print('center: ', nx.center(graph))
print('periphery: ', nx.periphery(graph))
res['connected'] = True
except Exception as e:
print('Graph not connected')
res['connected'] = False
res['density'] = '{:.6f}'.format(nx.density(graph))
res['Avg_degree'] = '{:.6f}'.format(
sum([i[1] for i in nx.degree(graph)]) / len(nx.degree(graph)))
res['Avg_weight'] = '{:.6f}'.format(
sum([graph[edge[0]][edge[1]]['weight'] for edge in graph.edges]) /
len([graph[edge[0]][edge[1]]['weight'] for edge in graph.edges]))
res['edges'] = len(graph.edges)
res['nodes'] = len(graph.nodes)
res['self_loops'] = len(list(nx.nodes_with_selfloops(graph)))
res['edge_to_node_ratio'] = '{:.6f}'.format(
len(graph.nodes) / len(graph.edges))
res['negative_edges'] = nx.is_negatively_weighted(graph)
print(algo.max_clique(graph))
# print('density: ', res['density'])
# print('Average degree: ', res['Avg_degree'])
# print('Average weight: ', res['Avg_weight'])
# print('edges: ', len(graph.edges))
# print('Nodes: ', len(graph.nodes))
# print('self loops: ', res['self_loops'])
# print('edges to nodes ratio: ', res['edge_to_node_ratio'])
# print('negative edges: ', res['negative_edges'])
# nodes = [node for node in graph.nodes]
# print(nodes)
return res
numberConnectedComponents = nx.number_connected_components(b)
# diameter(b)
# This will work only for graphs that are connected
diameter = -1
if numberConnectedComponents == 1:
diameter = nx.diameter(b)
#print(diameter, sizeMaxClique)
# The maximum clique is returned as a set of nodes
# max_clique(b)
maxClique = naa.max_clique(b)
sizeMaxClique = len(maxClique)
print (diameter, sizeMaxClique)
# The dominating set is returned as a set of nodes
# min_weighted_dominating_set(b)
minDominatingSet = naa.min_weighted_dominating_set(b)
sizeMinDominatingSet = len(minDominatingSet)
# The number of maximal cliques in the graph
# graph_number_of_cliques(b)
numberOfCliques = nx.graph_number_of_cliques(b)
print (numberConnectedComponents,diameter,sizeMaxClique,sizeMinDominatingSet,numberOfCliques)
vertex_colored_graph.node(i,
style='filled',
fillcolor=colors[vertex_coloring.get(i)])
# vertex_colored_graph.view(filename='vertex_colored_graph', quiet_view=True)
print("d", file=main)
edge_coloring = nx.greedy_color(nx.line_graph(Main_graph))
print(edge_coloring, file=main)
edge_colored_graph = gv.Graph()
for i in edge_coloring:
edge_colored_graph.edge(i[0], i[1], color=colors[edge_coloring.get(i)])
for i in Main_graph.nodes:
edge_colored_graph.node(i)
# edge_colored_graph.view(filename='edge_colored_graph', quiet_view=True)
a = nx.find_cliques(Main_graph)
print("e", file=main)
maximum_clique = approximation.max_clique(Main_graph)
print(maximum_clique, file=main)
maximum_clique_list = []
for i in maximum_clique:
maximum_clique_list.append(i)
maximum_clique_subgraph = gv.Graph()
for i in range(0, len(maximum_clique_list)):
maximum_clique_subgraph.node(maximum_clique_list[i])
for j in range(i + 1, len(maximum_clique_list)):
if i != j:
maximum_clique_subgraph.edge(maximum_clique_list[i],
maximum_clique_list[j])
# maximum_clique_subgraph.view(filename='maximum_clique_subgraph')
print("f", file=main)
independent_set_graph = gv.Graph()
maximum_independent_set = [
next_level_communities = next(communities_generator)
next_level_communities
# In[54]:
approximation.k_components(G)
# In[55]:
## This crashes the session
approximation.max_clique(G)
# In[86]:
#lab.write_pandas_to_csv_on_gcs(bucket='swe-files' ,data=dfxtest2 ,fileName='swe-files/dfxtest2.csv')
# In[32]:
##### Write the dataframe to BQ.
#dfxtest2.to_gbq('ConnectionModeling.dfxtest2', "network-sec-analytics", verbose=True, reauth=False,
#if_exists='replace', private_key=None)
def test_null_graph(self):
G = nx.null_graph()
assert_equal(len(max_clique(G)), 0)
def test_max_clique_smoke():
# smoke test
G = nx.Graph()
assert_equal(len(apxa.max_clique(G)),0)
def setup(graph, num_players, num_seeds):
print approx.max_clique(graph)
return list(approx.max_clique(graph))
def test_complete_graph(self):
graph = nx.complete_graph(30)
# this should return the entire graph
mc = max_clique(graph)
assert 30 == len(mc)
def test_max_clique_smoke():
# smoke test
G = nx.Graph()
eq_(len(apxa.max_clique(G)), 0)
def cliques_in_nodes(graph):
return [apxa.max_clique(graph)]
def cliques_for_nodes(G, nodes):
return [apxa.max_clique(G)]
def test_max_clique():
# create a complete graph
graph = nx.complete_graph(30)
# this should return the entire graph
mc = apxa.max_clique(graph)
assert_equals(30, len(mc))
def test_max_clique_smoke():
# smoke test
G = nx.Graph()
assert_equal(len(apxa.max_clique(G)), 0)
def test_null_graph(self):
G = nx.null_graph()
eq_(len(max_clique(G)), 0)
import util import networkx as nx from networkx.algorithms import approximation from networkx.algorithms import connectivity state_ = 15 input_ = 4 output_ = 1 file_name = 'test.kiss2' repeated = 5 experiment = 10 util.create_fsm(state_, input_, output_, file_name) G, g_data = util.create_graph(file_name) print(nx.average_neighbor_degree(G)) print(approximation.max_clique(G)) print(nx.k_nearest_neighbors(G)) print(nx.min_edge_cover(G))
def test_complete_graph(self):
graph = nx.complete_graph(30)
# this should return the entire graph
mc = max_clique(graph)
eq_(30, len(mc))
def test_max_clique():
# create a complete graph
graph = nx.complete_graph(30)
# this should return the entire graph
mc = apxa.max_clique(graph)
eq_(30, len(mc))
def find_max_clique_approx(graph_):
'''
Wrapper for suitable time estimation
'''
return max_clique(graph_)
def create_graph(edgelist):
G = nx.DiGraph()
G.add_weighted_edges_from(edgelist)
# Graph layout
pos = nx.spring_layout(G)
# Remove nodes with out-degree = 1------------------------------------------
outdeg = nx.degree(G)
while 1 in outdeg.values():
to_remove = [n for n in outdeg if outdeg[n] == 1]
G.remove_nodes_from(to_remove)
# Remove edges also checking the two values of the tuple
edgelist = [x for x in edgelist if x[0] not in to_remove]
edgelist = [x for x in edgelist if x[1] not in to_remove]
outdeg = nx.degree(G)
# ---------------------------------------------------------------------------
# Node size ================================================================
d = nx.degree(G)
nx.draw_networkx_nodes(G, pos, nodelist=d.keys(), node_size=[v * 100 for v in d.values()])
# ===========================================================================
nx.draw_networkx_nodes(G, pos, cmap=plt.get_cmap("jet"), node_size=1)
edge_labels = dict([((u, v), d["weight"]) for u, v, d in G.edges(data=True)])
nx.draw_networkx_edges(G, pos, width=0.5, alpha=0.2)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
labels = {}
for node in G.nodes():
labels[node] = node
nx.draw_networkx_labels(G, pos, labels, font_size=8)
if not len(G) == 1:
from networkx.algorithms import approximation as apxm
print apxm.min_edge_dominating_set(G)
print apxm.max_clique(G)
print apxm.maximum_independent_set(G)
print apxm.min_maximal_matching(G)
print nx.degree_centrality(G)
plt.savefig("directed.png") # save as png
# clean old graph
plt.clf()
def test_max_clique():
# create a complete nxgraph
graph = nx.complete_graph(30)
# this should return the entire nxgraph
mc = apxa.max_clique(graph)
assert_equals(30, len(mc))
def cliques_for_nodes(graph):
return [apprx.max_clique(graph)]
def test_null_graph(self):
G = nx.null_graph()
assert len(max_clique(G)) == 0
def cliques_for_nodes(G, nodes):
return [apxa.max_clique(G)]
def test_max_clique_smoke():
# smoke test
G = nx.Graph()
eq_(len(apxa.max_clique(G)),0)
def find_max_clique(points):
g = nx.Graph()
g.add_edges_from(points)
import pdb
pdb.set_trace()
print(max_clique(g))
