def abstract(self, graph):
graph = edengraphtools._edge_to_vertex_transform(graph)
tmpgraph = edengraphtools._revert_edge_to_vertex_transform(graph)
abstract_graph = make_abstract(tmpgraph)
_abstract_graph = edengraphtools._edge_to_vertex_transform(abstract_graph)
for n, d in _abstract_graph.nodes(data=True):
if 'contracted' not in d:
d['contracted'] = set()
getabstr = {contra: node for node, d in _abstract_graph.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]:
_abstract_graph.node[getabstr[n1]]['contracted'].add(n)
# case2: neighbors belong to different gangs...
else:
blub = set(_abstract_graph.neighbors(getabstr[n1])) & set(_abstract_graph.neighbors(getabstr[n2]))
for blob in blub:
if 'contracted' in _abstract_graph.node[blob]:
_abstract_graph.node[blob]['contracted'].add(n)
else:
_abstract_graph.node[blob]['contracted'] = set([n])
return _abstract_graph
def make_graphs_static(ngraphs=100,
graphsize=5,
node_labels=5,
edge_labels=5,
maxdeg=3,
labeldistribution='real',
nocycles=False):
l = []
seen = {}
failcount = 0
while len(l) < ngraphs:
g = make_graph_strict(graphsize,
node_labels,
edge_labels,
maxdeg,
dist=labeldistribution,
allow_cycles=not nocycles)
harsch = glcip.graph_hash(
edeng._edge_to_vertex_transform(g.copy()),
get_node_label=lambda id, node: hash(node['label']))
if harsch not in seen:
seen[harsch] = 1
l.append(g)
failcount = 0
else:
#gprint(g)
failcount += 1
assert failcount < 10, "failed 10 times in a row to generate an unseen rand graph, check your params"
return l
def abstract_graph(self, base_graph):
'''
we need to make an abstraction Ooo
'''
# create the abstract graph and populate the contracted set
abstract_graph = rna_forgi.get_abstr_graph(base_graph.graph['structure'], max(base_graph.nodes()) + 1)# DOES NOT EXIST ANYMORE ignore_inserts=self.ignore_inserts)
abstract_graph = _edge_to_vertex_transform(abstract_graph)
completed_abstract_graph = rna_forgi.edge_parent_finder(abstract_graph, base_graph)
# eden is forcing us to set a label and a contracted attribute.. lets do this
for n, d in completed_abstract_graph.nodes(data=True):
if 'edge' in d:
d['label'] = 'e'
# in the abstract graph , all the edge nodes need to have a contracted attribute.
# originaly this happens naturally but since we make multiloops into one loop
# there are some left out
for n, d in completed_abstract_graph.nodes(data=True):
if 'contracted' not in d:
d['contracted'] = set()
completed_abstract_graph.graph['original']=base_graph
completed_abstract_graph.graph['mod_dict']={0:123, len(base_graph.graph['sequence'])-1:555}
return completed_abstract_graph
def postprocess_transformer_out(graph):
# 1. the original graph needs to be directed
ograph = _edge_to_vertex_transform(graph.graph['original'])
graph.graph['original'] = rna.expanded_rna_graph_to_digraph(ograph)
# 2. our convention is, that node ids are not overlapping ,, complying by optimistic renaming..
graph = nx.convert_node_labels_to_integers(graph,first_label=1000)
return graph
def ses_to_graph(ses):
structure, energy, sequence = ses
base_graph = eden_rna.sequence_dotbracket_to_graph(seq_info=sequence, seq_struct=structure)
base_graph = _edge_to_vertex_transform(base_graph)
base_graph = rna.expanded_rna_graph_to_digraph(base_graph)
base_graph.graph['energy'] = energy
base_graph.graph['sequence'] = sequence
base_graph.graph['structure'] = structure
return base_graph
def transform(self, inputs):
'''
Parameters
----------
inputs : list of things
Returns
-------
graphwrapper : iterator
'''
return [_edge_to_vertex_transform(i) for i in inputs]
def wrap(self, graph):
"""
Parameters
----------
graph: nx.graph
Returns
-------
graphdecomposer
"""
graph = edengraphtools._edge_to_vertex_transform(graph)
return (graph,self.abstract(graph))
def make_abstract(graph):
'''
graph should be the same expanded graph that we will feed to extract_cips later...
Parameters
----------
graph
Returns
-------
'''
if isinstance(graph, nx.DiGraph):
graph = graph.to_undirected()
graph2 = edengraphtools._revert_edge_to_vertex_transform(graph)
graph2 = edge_type_in_radius_abstraction(graph2)
graph2 = edengraphtools._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
def transform(self, sequences):
"""
Parameters
----------
sequences : iterable over rna sequences
Returns
-------
list of RnaGraphWrappers
"""
result = []
for sequence in sequences:
# get structure
structure, energy, sequence = self.NNmodel.transform_single(sequence)
# FIXING STRUCTURE
structure, sequence = fix_structure(structure, sequence)
if structure == None:
result.append(None)
continue
# built base_graph
base_graph = eden_rna.sequence_dotbracket_to_graph(seq_info=sequence, seq_struct=structure)
base_graph = _edge_to_vertex_transform(base_graph)
base_graph = expanded_rna_graph_to_digraph(base_graph)
base_graph.graph['energy'] = energy
base_graph.graph['sequence'] = sequence
base_graph.graph['structure'] = structure
if self.fold_only:
result.append(base_graph)
else:
result.append(self.abstract_graph(base_graph))
# result.append(
# (sequence, structure, base_graph, self.abstract_graph(base_graph))
#)
return result
def _prepare_extraction(self):
# somehow check that there are only 2 layers
# oO
# lets get started
if '_base_graph' in self.__dict__:
return
self._base_graph= edengraphtools._edge_to_vertex_transform(self._unaltered_graph.graph['original'].copy())
#self._base_graph= edengraphtools._edge_to_vertex_transform(self.get_layers()[-1].copy()) # does not work/// why?
self._abstract_graph = edengraphtools._edge_to_vertex_transform(self._unaltered_graph.copy() )
# now i want to add the edges of the base graph to the contracted set of the abstract :)
# SOME TRNASFORMERS (EG RNA) want to do this themselfes also the code below is only for undirected graphs..
# sososo
if not self.calc_contracted_edge_nodes:
#print 'mindecomp _prep_extraction.. skipping contracted buulding ... this should only be the case with rna'
return
def base_graph_neighbors(n):
if type(self._base_graph) == nx.DiGraph:
return set(self._base_graph.neighbors(n)+self._base_graph.predecessors(n))
else:
return self._base_graph.neighbors(n)
# make a dictionary that maps from base_graph_node -> node in contracted graph
getabstr = {contra: node for node, d in self._abstract_graph.nodes(data=True) for contra in d.get('contracted', [])}
# so this basically assigns edges in the base_graph to nodes in the abstract graph.
for n, d in self._base_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 = base_graph_neighbors(n)
# case1: ok those belong to the same gang so we most likely also belong there.
try:
if getabstr[n1] == getabstr[n2]:
self._abstract_graph.node[getabstr[n1]]['contracted'].add(n)
# case2: neighbors belong to different gangs...
else:
blub = set(self._abstract_graph.neighbors(getabstr[n1])) & set(self._abstract_graph.neighbors(getabstr[n2]))
for blob in blub:
if 'contracted' in self._abstract_graph.node[blob]:
self._abstract_graph.node[blob]['contracted'].add(n)
else:
self._abstract_graph.node[blob]['contracted'] = set([n])
except:
traceback.print_stack()
print "key error in minor decompose.py %d %d %d" % (n1,n2,n)
import structout as so
def pg(g):
for n,d in g.nodes(data=True):
d['id']=str(n)
return g
so.gprint(pg(self._base_graph), size=35, label='id')
so.gprint(pg(self._abstract_graph),size=35, label='id')
for n,d in self._abstract_graph.nodes(data=True):
print d
exit()
def pre_vectorizer_graph(self, nested=True, fcorrect=False, base_only=False):
"""
Parameters
----------
nested: nested minor + base graph
fcorrect: introduce nodes that aid the forgi abstraction
base_only: only return the base graph
Returns
-------
nx.graph
"""
if self.pre_vectorizer_rm_f and self.pre_vectorizer_nested:
print "not sure if this works.. rnadecomposer pre_vec_graph"
if self.pre_vectorizer_rm_f == False:
return super(self.__class__, self).pre_vectorizer_graph(nested=self.pre_vectorizer_nested)
# else
backup = self._unaltered_graph.copy()
g=self._unaltered_graph
if g:
if self.pre_vectorizer_rm_f:
delset = []
for n, d in g.nodes(data=True):
if d['label'] == "F":
down = self.nextnode(g, n)
up = self.nextnode(g, n, down_direction=False)
delset.append((n, down, up))
for r, d, u in delset:
# print g.node[d[0]]
# we copy the label of the adjacent edge to r
g.node[r] = g.node[d[0]].copy()
# print g.node[r]
# g.node[r]={"label":'-','edge':True}
# delete neighbors
g.remove_nodes_from([d[0], u[0]])
# rewire neighbors of neighbors
g.add_edge(r, d[1])
g.add_edge(u[1], r)
# print r,d,u
#g2=g.graph['original'] eden should preserve the dict..
self._unaltered_graph =edengraphtools._edge_to_vertex_transform(g)
#g.graph['original']=g2
g = super(self.__class__, self).pre_vectorizer_graph(nested=self.pre_vectorizer_nested)
#import graphlearn.utils.ascii as asc
#asc.printrow([g],size=60)
#exit()
self._unaltered_graph = backup
return g
def transform(self, inputs):
return [(edengraphtools._edge_to_vertex_transform(i),self.abstract(i)) for i in inputs]
def _edge_to_vertex(graph):
return eg._edge_to_vertex_transform(graph)
def transform_single(self, graph):
product = self.abstract(graph)
product.graph['original']= edengraphtools._edge_to_vertex_transform(graph)
return product
def _edge_to_vertex(graph):
return eg._edge_to_vertex_transform(graph)
