def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node),
color='black', style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
python类Edge()的实例源码
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node),
color='black', style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
def _to_pydot(self, graph):
import pydot
color = hash(self.head) & 0xffffff
if not (color & 0x808080):
color |= 0x808080
def new_leaf(leaf):
node = pydot.Node(id(leaf), label=repr(leaf))
graph.add_node(node)
return node
subnodes = [kid._to_pydot(graph) if is_stree(kid) else new_leaf(kid) for kid in self.tail]
node = pydot.Node(id(self), style="filled", fillcolor="#%x"%color, label=self.head)
graph.add_node(node)
for subnode in subnodes:
graph.add_edge(pydot.Edge(node, subnode))
return node
def debugPlot(self, outfile):
graph = pydot.Dot(graph_type='digraph')
nodes = dict()
for layerCfg in self.layerCfgs:
node = pydot.Node(layerCfg.name)
graph.add_node(node)
nodes[layerCfg.name] = node
for inp in layerCfg._inputs:
if isinstance(inp,int):
node = pydot.Node("input[{}]".format(inp))
graph.add_node(node)
nodes[str(inp)] = node
for layerCfg in self.layerCfgs:
for inp in layerCfg._inputs:
if isinstance(inp,int):
inp = str(inp)
edge = pydot.Edge(nodes[inp],nodes[layerCfg.name])
graph.add_edge(edge)
graph.write_png(outfile)
def make_corenlp_tree(data_in_path, data_out_path, num_sentence):
tree = ET.parse(data_in_path)
root = tree.getroot()
i = 0
for dependencies in root.findall(".//dependencies"):
if dependencies.get('type') != 'collapsed-dependencies':
continue
i += 1
if i != num_sentence:
continue
graph = pydot.Dot()
graph.set_type('digraph')
for dep in dependencies.findall('dep'):
from_edge = dep.find('governor').text + ' _ ' + dep.find('governor').get('idx')
to_edge = dep.find('dependent').text + ' _ ' + dep.find('dependent').get('idx')
if to_edge in ',':
to_edge = r'\,'
graph.add_edge(pydot.Edge(from_edge, to_edge))
graph.write_jpeg(data_out_path)
break
def graph_from_idx_edges(edges):
graph = pydot.Dot(graph_type = 'digraph')
for edge in edges:
idx1 = str(edge[0][0])
label1 = str(edge[0][1])
idx2 = str(edge[1][0])
label2 = str(edge[1][1])
graph.add_node(pydot.Node(idx1, label=label1))
graph.add_node(pydot.Node(idx2, label=label2))
graph.add_edge(pydot.Edge(idx1, idx2))
return graph
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node),
color='black', style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node),
color='black', style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
def to_pydot(self):
"""Return a pydot digraph from a StepTree."""
graph = pydot.Dot(graph_type='digraph')
# make sure Root shows up in single node trees
if self.root_name:
graph.add_node(pydot.Node(self._step_graph_label(self.root_name)))
for parent, children in self.children.items():
for child in children:
graph.add_edge(pydot.Edge(
self._step_graph_label(parent),
self._step_graph_label(child)
))
return graph
textFeatureExtraction.py 文件源码
项目：pyOpenAireTextClassifier
作者: tyiannak
项目源码
文件源码
阅读 32
收藏 0
点赞 0
评论 0
def drawGraphFromSM2(SM, names, outFile, Cut):
graph = pydot.Dot(graph_type='graph')
# THRESHOLD SM:
nonZeroMean = np.mean(SM[SM.nonzero()])
if Cut:
T = 5.0 * nonZeroMean
else:
T = 0.0;
for i in range(SM.shape[0]):
for j in range(SM.shape[0]):
if SM[i,j] <= T:
SM[i,j] = 0.0
else:
SM[i,j] = 1.0
numOfConnections = sum(SM, axis = 0)
#fig = plt.figure(1)
#plot1 = plt.imshow(SM, origin='upper', cmap=cm.gray, interpolation='nearest')
#plt.show()
numOfConnections = 9*numOfConnections / max(numOfConnections)
for i,f in enumerate(names):
if sum(SM[i,:])>0:
fillColorCurrent = "{0:d}".format(int(ceil(numOfConnections[i])))
# NOTE: SEE http://www.graphviz.org/doc/info/colors.html for color schemes
node = pydot.Node(f, style="filled", fontsize="8", shape="egg", fillcolor=fillColorCurrent, colorscheme = "reds9")
graph.add_node(node)
for i in range(len(names)):
for j in range(len(names)):
if i<j:
if SM[i][j] > 0:
#gr.add_edge((names[i], names[j]))
edge = pydot.Edge(names[i], names[j])
graph.add_edge(edge)
graph.write_png(outFile)
def addnodes(self, var):
if var not in self.seen:
if isinstance(var, Variable):
value = '(' + (', ').join(['%d' % v for v in var.size()]) + ')'
self.style_params["label"] = value
self.dot.add_node(pydot.Node(str(id(var)), **self.style_params))
else:
value = str(type(var).__name__)
self.style_layers["label"] = value
if value == "ConvNd":
self.style_layers["fillcolor"] = "cyan"
elif value == "BatchNorm":
self.style_layers["fillcolor"] = "darkseagreen"
elif value == "Threshold":
self.style_layers["fillcolor"] = "crimson"
self.style_layers["label"] = "ReLU"
elif value == "Add":
self.style_layers["fillcolor"] = "darkorchid"
elif value == "AvgPool2d":
self.style_layers["fillcolor"] = "gold"
elif value == "Linear":
self.style_layers["fillcolor"] = "chartreuse"
elif value == "View":
self.style_layers["fillcolor"] = "brown"
else:
self.style_layers["fillcolor"] = "aquamarine"
self.dot.add_node(pydot.Node(str(id(var)), **self.style_layers))
self.seen.add(var)
if hasattr(var, 'previous_functions'):
for u in var.previous_functions:
# if not isinstance(u[0], Variable):
self.dot.add_edge(pydot.Edge(str(id(u[0])), str(id(var))))
self.addnodes(u[0])
def __create_link_flow(self, h1, h2, f):
e = pydot.Edge(h1, h2)
e.set_fontname(self.font_name)
e.set_fontsize(self.label_size)
if f % 1 == 0: # integer flow
e.set_label(str(f))
else:
e.set_label("%.2f" % f)
e.set_fontcolor(self.accent_color)
e.set_color(self.accent_color)
return e
def add_edge(self, f, t, graph):
if f: graph.add_edge(pydot.Edge(f, t))
return t
def add_child(graph, child_id, child_label, parent_id, colour):
"""
http://www.graphviz.org/doc/info/shapes.html#polygon
"""
node = pydot.Node(child_id, style="filled", fillcolor=colour, label=child_label, shape="polygon", fontname=FONT)
graph.add_node(node)
graph.add_edge(pydot.Edge(parent_id, node))
def graph_from_edges_ex(edge_list, title, directed=False):
if directed:
graph = pydot.Dot(graph_type='digraph')
else:
graph = pydot.Dot(graph_type='graph')
for edge in edge_list:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
# add node
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
# add edege
graph.add_edge(pydot.Edge(id1, id2))
graph.set_label( title )
return graph
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def knock_44(Sent):
tree_graph=pydot.Dot(graph_type='digraph',fontname="Microsoft YaHei")
nodes=[]
for ind, p in enumerate(Sent.phrases):
nodes.append(pydot.Node(p.str,fontname="Microsoft YaHei"))
tree_graph.add_node(nodes[ind])
for ind, p in enumerate(Sent.phrases):
if p.father!=-1:
tree_graph.add_edge(pydot.Edge(nodes[ind],nodes[p.father]))
tree_graph.write_png("knock_44.png")
# In[152]:
def visualize_tree(f_name,number_trees=3):
tree = etree.parse(f_name)
root = tree.getroot()
sentences = root.xpath("/root/document/sentences/sentence")
for idx, sentence in enumerate(sentences):
tree_graph = pydot.Dot(graph_type='digraph')
basic_dependencies = sentence.xpath(
"./dependencies[@type='basic-dependencies']/dep")
for dep in basic_dependencies:
father = "{no}_{word}".format(
no=dep[0].get("idx"), word=dep[0].text)
child = "{no}_{word}".format(
no=dep[1].get("idx"), word=dep[1].text)
tree_graph.add_node(pydot.Node(father))
tree_graph.add_node(pydot.Node(child))
tree_graph.add_edge(pydot.Edge(child, father))
tree_graph.write_png("sentence_{no}.png".format(no=idx))
if idx > number_trees-1:
break
# In[91]:
def add_edge(self, a, b):
"""checks if the edge already exists, if not, creates one from a2b
:param a: Node a
:param b: Node b
"""
if a is None or b is None:
return
for edge_obj in self.graph.get_edge_list():
if a.get_name() in edge_obj.obj_dict["points"] and \
b.get_name() in edge_obj.obj_dict["points"]:
break
else:
# such an edge doesn't exist. create it
self.graph.add_edge(pydot.Edge(a, b))
def __init__ (self, src, dst):
'''
Class constructor.
@type src: Mixed
@param src: Edge source
@type dst: Mixed
@param dst: Edge destination
'''
# the unique id for any edge (provided that duplicates are not allowed) is the combination of the source and
# the destination stored as a long long.
self.id = (src << 32) + dst
self.src = src
self.dst = dst
# general graph attributes.
self.color = 0x000000
self.label = ""
# gml relevant attributes.
self.gml_arrow = "none"
self.gml_stipple = 1
self.gml_line_width = 1.0
####################################################################################################################
def render_edge_graphviz (self, graph):
'''
Render an edge suitable for use in a Pydot graph using the set internal attributes.
@type graph: pgraph.graph
@param graph: Top level graph object containing the current edge
@rtype: pydot.Edge()
@return: Pydot object representing edge
'''
import pydot
# no need to validate if nodes exist for src/dst. graphviz takes care of that for us transparently.
dot_edge = pydot.Edge(self.src, self.dst)
if self.label:
dot_edge.label = self.label
dot_edge.color = "#%06x" % self.color
return dot_edge
####################################################################################################################
def pydot__tree_to_png(tree, filename):
import pydot
graph = pydot.Dot(graph_type='digraph', rankdir="LR")
i = [0]
def new_leaf(leaf):
node = pydot.Node(i[0], label=repr(leaf))
i[0] += 1
graph.add_node(node)
return node
def _to_pydot(subtree):
color = hash(subtree.data) & 0xffffff
color |= 0x808080
subnodes = [_to_pydot(child) if isinstance(child, Tree) else new_leaf(child)
for child in subtree.children]
node = pydot.Node(i[0], style="filled", fillcolor="#%x"%color, label=subtree.data)
i[0] += 1
graph.add_node(node)
for subnode in subnodes:
graph.add_edge(pydot.Edge(node, subnode))
return node
_to_pydot(tree)
graph.write_png(filename)
def plot(model, to_file='model.png'):
graph = pydot.Dot(graph_type='digraph')
if type(model) == Sequential:
previous_node = None
written_nodes = []
n = 1
for node in model.get_config()['layers']:
# append number in case layers have same name to differentiate
if (node['name'] + str(n)) in written_nodes:
n += 1
current_node = pydot.Node(node['name'] + str(n))
written_nodes.append(node['name'] + str(n))
graph.add_node(current_node)
if previous_node:
graph.add_edge(pydot.Edge(previous_node, current_node))
previous_node = current_node
graph.write_png(to_file)
elif type(model) == Graph:
# don't need to append number for names since all nodes labeled
for input_node in model.input_config:
graph.add_node(pydot.Node(input_node['name']))
# intermediate and output nodes have input defined
for layer_config in [model.node_config, model.output_config]:
for node in layer_config:
graph.add_node(pydot.Node(node['name']))
# possible to have multiple 'inputs' vs 1 'input'
if node['inputs']:
for e in node['inputs']:
graph.add_edge(pydot.Edge(e, node['name']))
else:
graph.add_edge(pydot.Edge(node['input'], node['name']))
graph.write_png(to_file)
def plot(model, to_file='model.png'):
graph = pydot.Dot(graph_type='digraph')
if type(model) == Sequential:
previous_node = None
written_nodes = []
n = 1
for node in model.get_config()['layers']:
# append number in case layers have same name to differentiate
if (node['name'] + str(n)) in written_nodes:
n += 1
current_node = pydot.Node(node['name'] + str(n))
written_nodes.append(node['name'] + str(n))
graph.add_node(current_node)
if previous_node:
graph.add_edge(pydot.Edge(previous_node, current_node))
previous_node = current_node
graph.write_png(to_file)
elif type(model) == Graph:
# don't need to append number for names since all nodes labeled
for input_node in model.input_config:
graph.add_node(pydot.Node(input_node['name']))
# intermediate and output nodes have input defined
for layer_config in [model.node_config, model.output_config]:
for node in layer_config:
graph.add_node(pydot.Node(node['name']))
# possible to have multiple 'inputs' vs 1 'input'
if node['inputs']:
for e in node['inputs']:
graph.add_edge(pydot.Edge(e, node['name']))
else:
graph.add_edge(pydot.Edge(node['input'], node['name']))
graph.write_png(to_file)
