def name_estimation(graph, group, layer, graphreference, vectorizer, nameestimator, subgraphs):
if subgraphs:
map(remove_eden_annotation, subgraphs)
try:
data = vectorizer.transform(subgraphs)
except:
draw.graphlearn(subgraphs, contract= False)
clusterids = nameestimator.predict(data)
#for d, g in zip(data, subgraphs):
# g.graph['hash_title'] = hash_function(d)
#draw.graphlearn(subgraphs,size=2, title_key='hash_title', edge_label='label')
for sg, clid in zip(subgraphs, clusterids):
for n in sg.nodes():
graph.node[n][group] = '-' if clid == -1 else str(clid)
# doing the contraction...
graph = contraction([graph], contraction_attribute=group, modifiers=[],
nesting=False, dont_contract_attribute_symbol='-').next()
# write labels
def f(n, d):
d['label'] = graphreference.node[max(d['contracted'])]['label'] \
if d['label'] == '-' else "L%sC%s" % (layer, d['label'])
node_operation(graph, f)
return graph
def transform(self, seqs, listof_start_end_weight_list=None):
"""Transforms the sequences in input into graphs.
Parameters
----------
seqs : iterable strings
Input sequences.
listof_start_end_weight_list : list of start_end_weight_lists
Each element in listof_start_end_weight_list specifies the start_end_weight_list
for a single graph.
Returns
-------
graphs : iterable graphs in Networkx format
List of graphs resulting from the transformation of sequences into folded structures.
"""
graphs = rnaplfold_to_eden(seqs,
window_size=self.window_size,
max_bp_span=self.max_bp_span,
avg_bp_prob_cutoff=self.avg_bp_prob_cutoff,
max_num_edges=self.max_num_edges)
if listof_start_end_weight_list is None:
graphs = list_reweight(graphs, start_end_weight_list=self.start_end_weight_list)
graphs = list_reweight(graphs, start_end_weight_list=self.start_end_weight_list,
attribute='level')
else:
graphs = listof_list_reweight(graphs,
listof_start_end_weight_list=listof_start_end_weight_list)
graphs = listof_list_reweight(graphs,
listof_start_end_weight_list=listof_start_end_weight_list,
attribute='level')
# annotate in node attribute 'type' the incident edges' labels
graphs = vertex_attributes.incident_edge_label(graphs,
level=self.contraction_level,
output_attribute='type',
separator='.')
# reduce all 'label' attributes of contracted nodes to a histogram to be written in the
# 'label' attribute of the resulting graph
label_modifier = contraction_modifier(attribute_in='type',
attribute_out='label',
reduction='set_categorical')
# reduce all 'weight' attributes of contracted nodes using a sum to be written in the
# 'weight' attribute of the resulting graph
weight_modifier = contraction_modifier(attribute_in='weight',
attribute_out='weight',
reduction='average')
modifiers = [label_modifier, weight_modifier]
# contract the graph on the 'type' attribute
graphs = contraction(graphs,
contraction_attribute='type',
modifiers=modifiers,
contraction_weight_scaling_factor=self.contraction_weight_scaling_factor,
nesting=True)
return graphs
def edge_type_in_radius_abstraction(graph):
'''
# the function needs to set a 'contracted' attribute to each node with a set of vertices that
# are contracted.
:param graph: any graph .. what kind? expanded? which flags musst be set?
:return: an abstract graph with node annotations that refer to the node ids it is contracting
'''
# annotate in node attribute 'type' the incident edges' labels
labeled_graph = vertex_attributes.incident_edge_label(
[graph], level=2, output_attribute='type', separator='.').next()
# do contraction
contracted_graph = contraction(
[labeled_graph], contraction_attribute='type', modifiers=[], nesting=False).next()
return contracted_graph
def edge_type_in_radius_abstraction(graph):
'''
# the function needs to set a 'contracted' attribute to each node with a set of vertices that
# are contracted.
:param graph: any graph .. what kind? expanded? which flags musst be set?
:return: an abstract graph with node annotations that refer to the node ids it is contracting
'''
# annotate in node attribute 'type' the incident edges' labels
labeled_graph = vertex_attributes.incident_edge_label(
[graph], level=2, output_attribute='type', separator='.').next()
# do contraction
contracted_graph = contraction([labeled_graph],
contraction_attribute='type',
modifiers=[],
nesting=False).next()
return contracted_graph
def contract(graph):
contracted_graph = contraction([graph], contraction_attribute="type", modifiers=[], nesting=False).next()
return contracted_graph
def abstract(self,
graph,
score_attribute='importance',
group='class',
debug=False):
'''
Parameters
----------
score_attribute
group
Returns
-------
'''
graph = self.vectorizer._edge_to_vertex_transform(graph)
graph2 = self.vectorizer._revert_edge_to_vertex_transform(graph)
if debug:
print 'abstr here1'
draw.graphlearn(graph2)
graph2 = self.vectorizer.annotate(
[graph2], estimator=self.rawgraph_estimator.estimator).next()
for n, d in graph2.nodes(data=True):
#d[group]=str(math.floor(d[score_attribute]))
d[group] = str(self.kmeans.predict(d[score_attribute])[0])
if debug:
print 'abstr here'
draw.graphlearn(graph2, vertex_label='class')
graph2 = contraction([graph2],
contraction_attribute=group,
modifiers=[],
nesting=False).next()
graph2 = self.vectorizer._edge_to_vertex_transform(graph2)
# find out to which abstract node the edges belong
# finding out where the edge-nodes belong, because the contractor cant possibly do this
getabstr = {
contra: node
for node, d in graph2.nodes(data=True)
for contra in d.get('contracted', [])
}
for n, d in graph.nodes(data=True):
if 'edge' in d:
# if we have found an edge node...
# lets see whos left and right of it:
n1, n2 = graph.neighbors(n)
# case1: ok those belong to the same gang so we most likely also belong there.
if getabstr[n1] == getabstr[n2]:
graph2.node[getabstr[n1]]['contracted'].add(n)
# case2: neighbors belong to different gangs...
else:
blub = set(graph2.neighbors(getabstr[n1])) & set(
graph2.neighbors(getabstr[n2]))
for blob in blub:
if 'contracted' in graph2.node[blob]:
graph2.node[blob]['contracted'].add(n)
else:
graph2.node[blob]['contracted'] = set([n])
return graph2
