def _frequency_decomposition(graph,
node_counts,
min_size=1,
max_size=None,
disjoint=True):
# a component is a connected component where all nodes
# have a count >= min_size and <= max_size
# select nodes
if max_size is None:
sel_nodes = [
node for node, count in node_counts.items() if min_size <= count
]
else:
if disjoint:
sel_nodes = [
node for node, count in node_counts.items()
if min_size <= count < max_size
]
else:
sel_nodes = [
node for node, count in node_counts.items()
if min_size <= count <= max_size
]
subgraphs = get_subgraphs_from_node_components(graph, [sel_nodes])
subgraph = subgraphs[0]
components = list(nx.connected_components(subgraph))
node_components = [set(c) for c in components]
new_subgraphs = get_subgraphs_from_node_components(graph, node_components)
return new_subgraphs
def decompose_node_join(graph_component, min_size=1, max_size=1):
if max_size < min_size:
max_size = min_size
new_subgraphs_list = []
new_signatures_list = []
# for each distinct pair of subgraphs
for i, (g, signature_i) in enumerate(
zip(graph_component.subgraphs, graph_component.signatures)):
g_node_set = set(g.nodes())
for j, (m, signature_j) in enumerate(
zip(graph_component.subgraphs, graph_component.signatures)):
if j > i:
m_node_set = set(m.nodes())
# check if the node set intersection has
# size equal or larger than min_size
intr_size = len(g_node_set.intersection(m_node_set))
if max_size is not None:
condition = intr_size >= min_size and intr_size <= max_size
else:
condition = intr_size >= min_size
if condition:
# if so return the union of the nodes
component = g_node_set.union(m_node_set)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, [component])
new_signature = serialize(
['node_join', min_size, max_size], signature_i,
signature_j)
new_subgraphs_list += new_subgraphs
new_signatures_list += [new_signature]
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_paired_neighborhoods(graph_component,
radius=None,
distance=None,
min_radius=0,
max_radius=1,
min_distance=0,
max_distance=0):
if radius is not None:
min_radius = max_radius = radius
if distance is not None:
min_distance = max_distance = distance
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = get_pairs(subgraph, min_radius, max_radius, min_distance,
max_distance)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
if distance == 0:
new_signature = serialize(['neighborhood', radius], signature)
else:
new_signature = serialize(
['paired_neighborhoods', radius, distance], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_break(graph_component, min_size=1, max_size=None, n_edges=1):
new_subgraphs_list = []
new_signatures_list = []
# for each distinct pair of subgraphs
for i, (g, signature_i) in enumerate(zip(graph_component.subgraphs, graph_component.signatures)):
components = []
effective_min_size = compute_effective_size(g,min_size)
effective_max_size = compute_effective_size(g,max_size)
for edges in combinations(g.edges(),n_edges):
gp = g.copy()
for i,j in edges:
gp.remove_edge(i, j)
if nx.number_connected_components(gp) >= 2:
for component in nx.connected_components(gp):
if effective_min_size <= len(component) <= effective_max_size:
components.append(tuple(sorted(component)))
components = set(components)
for component in components:
new_subgraphs = get_subgraphs_from_node_components(graph_component.graph, [component])
new_signature = serialize(['nbreak', min_size, n_edges], signature_i)
new_subgraphs_list += new_subgraphs
new_signatures_list += [new_signature]
gc = GraphComponent(
graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_intersection(graph_component_A, graph_component_B):
new_subgraphs_list = []
new_signatures_list = []
for g, signature_A in zip(graph_component_A.subgraphs,
graph_component_A.signatures):
g_node_set = set(g.nodes())
for m, signature_B in zip(graph_component_B.subgraphs,
graph_component_B.signatures):
m_node_set = set(m.nodes())
# check the node set intersection
intr_size = len(g_node_set.intersection(m_node_set))
if intr_size >= 1 and g_node_set != m_node_set:
component = g_node_set.intersection(m_node_set)
if len(component) > 0:
new_subgraph = get_subgraphs_from_node_components(
graph_component_A.graph, [component])
new_subgraphs_list += new_subgraph
new_signature = serialize(['intersection'], signature_A,
signature_B)
new_signatures_list.append(new_signature)
gc = GraphComponent(graph=graph_component_A.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_pair(graph_component, distance=1):
new_subgraphs_list = []
new_signatures_list = []
components_memory = set()
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = pair_decomposition(graph_component.graph,
graph_component.subgraphs,
distance=distance)
new_components = []
for component in components:
c = tuple(component)
if c not in components_memory:
new_components.append(component)
components_memory.add(c)
if new_components:
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, new_components)
new_signature = serialize(['pair', distance], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_pair_binary(graph_component_first,
graph_component_second,
distance=1,
keep_second_component=True):
new_subgraphs_list = []
new_signatures_list = []
near_sets, dist_sets = preprocess_distances(graph_component_first.graph,
distance)
# for each distinct pair of subgraphs
for g, signature_g in zip(graph_component_first.subgraphs,
graph_component_first.signatures):
g_node_set = set(g.nodes())
g_near_set = set()
g_dist_set = set()
for u in g_node_set:
g_near_set.update(near_sets[u])
g_dist_set.update(dist_sets[u])
g_dist_set = g_dist_set.difference(g_near_set)
if len(g_dist_set) > 0:
for m, signature_m in zip(graph_component_second.subgraphs,
graph_component_second.signatures):
m_node_set = set(m.nodes())
# if there is at least one node in m that is at the desired
# distance and if there is no node in m that has a smaller
# distance then make a component from the union of the nodes
# for each node in g consider the set A of all nodes at
# distance less than max and the set B of all nodes at distance
# equal to max
# consider the intersection of A with nodes in m:
# this must be empty
# consider the intersection of B with nodes in m:
# this must be not empty
near_intr_size = len(g_near_set.intersection(m_node_set))
dist_intr_size = len(g_dist_set.intersection(m_node_set))
condition = near_intr_size == 0 and dist_intr_size != 0
if condition:
if keep_second_component:
component = g_node_set.union(m_node_set)
else:
component = g_node_set
new_subgraph = get_subgraphs_from_node_components(
graph_component_first.graph, [component])[0]
from eden.display import line_serialize_graph
#print(line_serialize_graph(new_subgraph))
new_subgraphs_list.append(new_subgraph)
new_signature = serialize(
['pair_binary', distance, keep_second_component],
signature_g, signature_m)
#print(new_signature)
new_signatures_list += new_signature
gc = GraphComponent(graph=graph_component_first.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_central_and_non_central(graph_component, k_top=2):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs, graph_component.signatures):
components = central_and_non_central_decomposition(subgraph, k_top)
new_subgraphs = get_subgraphs_from_node_components(graph_component.graph, components)
new_signature = serialize(['central_and_non_central', k_top], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(
graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_communities(graph_component):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = greedy_modularity_communities(subgraph)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(['communities'], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_graphlet(graph_component, size=5):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = graphlet_decomposition(subgraph, size=size)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(['graphlet', size], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_dilatate(graph_component, radius=1):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
component = get_component_neighborhood_component(
graph_component.graph, subgraph, radius)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, [component])
new_signature = serialize(['dilatate', radius], signature)
new_subgraphs_list += new_subgraphs
new_signatures_list.append(new_signature)
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_cycles_and_non_cycles(graph_component):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = cycle_and_non_cycle_decomposition(subgraph)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(['cycles_and_non_cycles'], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_relation(relation_graph_component,
graph_component,
type_of='single'):
new_subgraphs_list = []
new_signatures_list = []
for g, signature_C in zip(relation_graph_component.subgraphs,
relation_graph_component.signatures):
g_node_set = set(g.nodes())
subcomponents = []
new_signatures = []
for m, signature in zip(graph_component.subgraphs,
graph_component.signatures):
m_node_set = set(m.nodes())
# check the node set intersection
intr_size = len(g_node_set.intersection(m_node_set))
if type_of == 'single':
condition = (intr_size == 1)
elif type_of == 'partial':
condition = intr_size >= 1
elif type_of == 'total':
condition = intr_size == len(g_node_set)
else:
condition = False
if condition:
# if so save the component
subcomponents.append(m_node_set)
new_signatures.append(signature)
if len(subcomponents) >= 2:
comp_combs = itertools.combinations(subcomponents, 2)
sig_combs = itertools.combinations(new_signatures, 2)
for component_pair, signature_pair in zip(comp_combs, sig_combs):
component_A, component_B = component_pair
signature_A, signature_B = signature_pair
component = component_A.union(component_B)
new_subgraph = get_subgraphs_from_node_components(
relation_graph_component.graph, [component])
new_subgraphs_list += new_subgraph
new_signature = serialize(['relation', type_of], signature_C,
signature_A, signature_B)
new_signatures_list.append(new_signature)
gc = GraphComponent(graph=relation_graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_degree_and_non_degree(graph_component, min_size=2, max_size=None):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs, graph_component.signatures):
components = degree_non_degree_decomposition(
subgraph, min_size=min_size, max_size=max_size)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(
['degree_and_non_degree', min_size, max_size], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(
graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_relation_binary(relation_graph_component,
graph_component_first,
graph_component_second,
type_of='single',
keep_second_component=True):
new_subgraphs_list = []
new_signatures_list = []
for g, signature_C in zip(relation_graph_component.subgraphs,
relation_graph_component.signatures):
g_node_set = set(g.nodes())
subcomponents_first, signatures_first = get_intersecting_subgraphs(
g_node_set, graph_component_first, type_of)
subcomponents_second, signatures_second = get_intersecting_subgraphs(
g_node_set, graph_component_second, type_of)
if len(subcomponents_first) >= 1 and len(subcomponents_second) >= 1:
component_pairs = itertools.product(subcomponents_first,
subcomponents_second)
signatures_pairs = itertools.product(signatures_first,
signatures_second)
for component_pair, signatures_pair in zip(component_pairs,
signatures_pairs):
component_A, component_B = component_pair
signature_A, signature_B = signatures_pair
if component_A != component_B:
if keep_second_component:
component = component_A.union(component_B)
else:
component = component_A
new_subgraph = get_subgraphs_from_node_components(
relation_graph_component.graph, [component])
new_subgraphs_list += new_subgraph
new_signature = serialize(
['relation_binary', type_of, keep_second_component],
signature_C, signature_A, signature_B)
new_signatures_list += new_signature
gc = GraphComponent(graph=relation_graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_negative(graph_component,
ktop=0,
part_importance_estimator=None):
new_subgraphs_list = []
new_signatures_list = []
for subgraph, signature in zip(graph_component.subgraphs,
graph_component.signatures):
components = negative_decomposition(
subgraph,
ktop=ktop,
part_importance_estimator=part_importance_estimator)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(['negative', ktop], signature)
new_signatures = [new_signature] * len(new_subgraphs)
new_subgraphs_list += new_subgraphs
new_signatures_list += new_signatures
gc = GraphComponent(graph=graph_component.graph,
subgraphs=new_subgraphs_list,
signatures=new_signatures_list)
return gc
def decompose_all_union(graph_component):
subgraphs = graph_component.subgraphs
# Warning: as it is hard to keep track of which components are
# finally united, we simply mangle all signatures into one
# as the sorted union of all signatures
new_signature = '_'.join(sorted(set(graph_component.signatures)))
new_subgraphs = []
new_signatures = []
if len(subgraphs) > 0:
g = subgraphs[0]
for subgraph in subgraphs[1:]:
g = nx.compose(g, subgraph)
components = nx.connected_components(g)
new_subgraphs = get_subgraphs_from_node_components(
graph_component.graph, components)
new_signature = serialize(['union'], new_signature)
new_signatures = [new_signature] * len(new_subgraphs)
gc = GraphComponent(
graph=graph_component.graph,
subgraphs=new_subgraphs,
signatures=new_signatures)
return gc
