def plot(root, to_file='vct_tree.png'): dot = pydot.Dot() dot.set('rankdir', 'TB') dot.set('concentrate', True) dot.set_node_defaults(shape='record') root.id = 0 label = 'root\nproof:{:d} disproof:{:d}'.format(root.proof, root.disproof) dot.add_node(pydot.Node(root.id, label=label)) node_stack = [] node_stack.append(root) count = 0 while len(node_stack): node = node_stack.pop() if node.parent is not None: parent_id = node.parent.id node_id = node.id dot.add_edge(pydot.Edge(parent_id, node_id)) for position, child_node in node.children.items(): count += 1 child_node.id = count label = str(position) + '\nproof:{:d} disproof:{:d}'.format( child_node.proof, child_node.disproof) dot.add_node(pydot.Node(child_node.id, label=label)) node_stack.append(child_node) _, extension = os.path.splitext(to_file) if not extension: extension = 'png' else: extension = extension[1:] dot.write(to_file, format=extension)
def make_graph(edge_list, 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]) graph.add_node( pydot.Node(id1, label='<<font face="MS Gothic">%s</font>>' % label1.rstrip("\r\n"))) graph.add_node( pydot.Node(id2, label='<<font face="MS Gothic">%s</font>>' % label2.rstrip("\r\n"))) graph.add_edge(pydot.Edge(id1, id2)) return graph
def lazy_create_node(node): if node.uid in function_nodes: # dot node already exists return function_nodes[node.uid] if node.is_primitive and not node.is_block and len( node.outputs ) == 1 and node.output.name == node.name: # skip the node name if redundant op_name = primitive_op_map.get(node.op_name, node.op_name) render_as_primitive = len(op_name) <= 4 size = 0.4 if render_as_primitive else 0.6 cur_node = pydot.Node( node.uid, label='"' + op_name + '"', shape='ellipse' if render_as_primitive else 'box', fixedsize='true' if render_as_primitive else 'false', height=size, width=size, fontsize=20 if render_as_primitive and len(op_name) == 1 else 12, penwidth=4 if node.op_name != 'Pass' and node.op_name != 'ParameterOrder' else 1) # TODO: Would be cool, if the user could pass a dictionary with overrides. But maybe for a later version. else: f_name = '\n' + node.name + '()' if node.name else '' cur_node = pydot.Node( node.uid, label='"' + node.op_name + f_name + '"', fixedsize='true', height=1, width=1.3, penwidth=4 if node.op_name != 'Pass' and node.op_name != 'ParameterOrder' else 1) dot_object.add_node(cur_node) function_nodes[node.uid] = cur_node return cur_node
def mnn_to_dot(mnn_file): "load a mnn file and create a dot file" if not os.path.exists(mnn_file): return None dot = pydot.Dot() dot.set('rankdir', 'TB') dot.set('concentrate', True) dot.set_node_defaults(shape='record') with open(mnn_file, 'rb') as f: buf = f.read() f.close() buf = bytearray(buf) net = Net.Net.GetRootAsNet(buf, 0) op_num = net.OplistsLength() for idx in range(op_num): op = net.Oplists(idx) name = "op_" + str(idx) op_type = op.Type() label = OpName.optype_to_name(op_type) main_type = op.MainType() if main_type == OpParameter.OpParameter.Convolution2D: union_conv2d = Convolution2D.Convolution2D() union_conv2d.Init(op.Main().Bytes, op.Main().Pos) common = union_conv2d.Common() KernelX = common.KernelX() KernelY = common.KernelY() input_channels = common.InputCount() output_channels = common.OutputCount() label += "\nshape:" + str(input_channels) + "*" + str(output_channels) \ + "*" + str(KernelX) + "*" + str(KernelY) if op_type != OpType.OpType.Input: node = pydot.Node(name, label=label, shape="egg", color='blue') dot.add_node(node) ts_num = net.TensorNameLength() for idx in range(ts_num): ts_name = net.TensorName(idx) name = "tensor_" + str(idx) label = ts_name node = dot.get_node(name) node = pydot.Node(name, label=label, shape="record", color='red') dot.add_node(node) for idx in range(op_num): op = net.Oplists(idx) name_op = "op_" + str(idx) input_len = op.InputIndexesLength() output_len = op.OutputIndexesLength() for idx_ts in range(input_len): name_tensor = "tensor_" + str(op.InputIndexes(idx_ts)) add_edge(dot, name_tensor, name_op) for idx_ts in range(output_len): name_tensor = "tensor_" + str(op.OutputIndexes(idx_ts)) add_edge(dot, name_op, name_tensor) return dot
def draw(parent_name, child_name, graph, parent_hash): """Draw parent and child nodes. Create and return new hash\n key declared to a child node.""" parent_node = pydot.Node(parent_hash, label=parent_name, shape='box') child_hash = str(uuid.uuid4()) # create hash key child_node = pydot.Node(child_hash, label=child_name, shape='box') graph.add_node(parent_node) graph.add_node(child_node) graph.add_edge(pydot.Edge(parent_node, child_node)) return child_hash
def add_elements(g, toks, defaults_graph=None, defaults_node=None, defaults_edge=None): if defaults_graph is None: defaults_graph = {} if defaults_node is None: defaults_node = {} if defaults_edge is None: defaults_edge = {} for element in toks: if isinstance(element, (pydot.Subgraph, pydot.Cluster)): add_defaults(element, defaults_graph) g.add_subgraph(element) elif isinstance(element, pydot.Node): add_defaults(element, defaults_node) g.add_node(element) elif isinstance(element, pydot.Edge): add_defaults(element, defaults_edge) g.add_edge(element) elif isinstance(element, pyparsing.ParseResults): for e in element: add_elements(g, [e], defaults_graph, defaults_node, defaults_edge) elif isinstance(element, DefaultStatement): if element.default_type == 'graph': default_graph_attrs = pydot.Node('graph', **element.attrs) g.add_node(default_graph_attrs) elif element.default_type == 'node': default_node_attrs = pydot.Node('node', **element.attrs) g.add_node(default_node_attrs) elif element.default_type == 'edge': default_edge_attrs = pydot.Node('edge', **element.attrs) g.add_node(default_edge_attrs) defaults_edge.update(element.attrs) else: raise ValueError("Unknown DefaultStatement: {0} ".format( element.default_type)) elif isinstance(element, P_AttrList): g.obj_dict['attributes'].update(element.attrs) else: raise ValueError("Unknown element statement: %r" % element)
def to_pydot_graph(dag, sub_graph=False, input_edge=None): import pydot_ng as pydot gid = dag['input'][2][:-2] graph = pydot.Dot(graph_type='digraph') if sub_graph: graph = pydot.Cluster(label='booster') dag_nx = dag_to_nx(dag) for n in dag_nx.nodes(): label = 'input' if dag[n][1] == 'input' else ( dag[n][1][0] + ('(' + ','.join('{}={}'.format(k, v) for k, v in dag[n][1][1].items()) + ')' if dag[n][1][1] else '')) label = 'input' if dag[n][1] == 'input' else ( dag[n][1][0] + ('(' + ','.join('{}'.format(v) for k, v in dag[n][1][1].items()) + ')' if dag[n][1][1] else '')) node_name = n if label == 'input': if sub_graph: continue node_name = label + gid if input_edge != None: outs = dag[n][2] if not isinstance(outs, list): outs = [outs] for o in outs: edge = pydot.Edge(input_edge, o) graph.add_edge(edge) if dag[n][1][0] == 'booster': graph.add_node(pydot.Node(n, label='booster')) for sd in dag[n][1][1]['sub_dags']: subgraph = to_pydot_graph(sd, sub_graph=True, input_edge=dag[n][0]) graph.add_subgraph(subgraph) else: node = pydot.Node(node_name, label=label) graph.add_node(node) for (f, t) in dag_nx.edges(): if f == 'input': if input_edge == None: f = 'input' + gid else: f = input_edge edge = pydot.Edge(f, t) graph.add_edge(edge) return graph
def edges2graph(edge_list): graph = pydot.Dot(graph_type='digraph') 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]) graph.add_node(pydot.Node(id1,label = label1)) graph.add_node(pydot.Node(id2,label = label2)) graph.add_edge(pydot.Edge(id1,id2)) return graph
def graph_from_edges_ex(edge_list, 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]) graph.add_node(pydot.Node(id1, label=label1)) graph.add_node(pydot.Node(id2, label=label2)) graph.add_edge(pydot.Edge(id1, id2)) return graph
def graph_4_edge(edges, gr_type='graph'): graph = pydot.Dot(graph_type=gr_type) for edge in edges: id1 = str(edge[0][0]) label1 = str(edge[0][1]) id2 = str(edge[1][0]) label2 = str(edge[1][1]) graph.add_node(pydot.Node(id1, label=label1)) graph.add_node(pydot.Node(id2, label=label2)) graph.add_edge(pydot.Edge(id1, id2)) return graph
def graph_write(edgelist): graph = pd.Dot(graph_type='digraph') for edge in edgelist: bef_num = str(edge[0][0]) aft_num = str(edge[1][0]) bef_word = str(edge[0][1]) aft_word = str(edge[1][1]) graph.add_node(pd.Node(bef_num, label=bef_word)) graph.add_node(pd.Node(aft_num, label=aft_word)) graph.add_edge(pd.Edge(bef_num, aft_num)) return graph
def visualization(sentence): # 有向グラフ graph = pydot.Dot(graph_type='digraph') for chunk in sentence: # dstから辿る source_i = chunk.index target_i = chunk.dst graph.add_node( pydot.Node(source_i, label=pattern.sub("", sentence[source_i].morphstr))) graph.add_node( pydot.Node(target_i, label=pattern.sub("", sentence[target_i].morphstr))) graph.add_edge(pydot.Edge(source_i, chunk.dst)) graph.write_png('knock44.png')
def create_graph(graph_info): dot = pydot.Dot() for node in graph_info['nodes']: dot.add_node(pydot.Node(node)) for node1, node2 in graph_info['edges']: dot.add_edge(pydot.Edge(node1, node2)) return dot
def model_to_dot(model, show_shapes=False, show_layer_names=True): dot = pydot.Dot() dot.set('rankdir', 'TB') dot.set('concentrate', True) dot.set_node_defaults(shape='record') if isinstance(model, Sequential): if not model.built: model.build() model = model.model layers = model.layers # Create graph nodes. for layer in layers: layer_id = str(id(layer)) # Append a wrapped layer's label to node's label, if it exists. layer_name = layer.name class_name = layer.__class__.__name__ if isinstance(layer, Wrapper): layer_name = '{}({})'.format(layer_name, layer.layer.name) child_class_name = layer.layer.__class__.__name__ class_name = '{}({})'.format(class_name, child_class_name) # Create node's label. if show_layer_names: label = '{}: {}'.format(layer_name, class_name) else: label = class_name # Rebuild the label as a table including input/output shapes. if show_shapes: try: outputlabels = str(layer.output_shape) except: outputlabels = 'multiple' if hasattr(layer, 'input_shape'): inputlabels = str(layer.input_shape) elif hasattr(layer, 'input_shapes'): inputlabels = ', '.join( [str(ishape) for ishape in layer.input_shapes]) else: inputlabels = 'multiple' label = '%s\n|{input:|output:}|{{%s}|{%s}}' % (label, inputlabels, outputlabels) node = pydot.Node(layer_id, label=label) dot.add_node(node) # Connect nodes with edges. for layer in layers: layer_id = str(id(layer)) for i, node in enumerate(layer.inbound_nodes): node_key = layer.name + '_ib-' + str(i) if node_key in model.container_nodes: for inbound_layer in node.inbound_layers: inbound_layer_id = str(id(inbound_layer)) layer_id = str(id(layer)) dot.add_edge(pydot.Edge(inbound_layer_id, layer_id)) return dot
def test_names_of_a_thousand_nodes(digraph): names = set(["node_%05d" % i for i in xrange(10 ** 4)]) for name in names: digraph.add_node(pydot.Node(name, label=name)) assert set([n.get_name() for n in digraph.get_nodes()]) == names
def test_quoting(): import string g = pydot.Dot() g.add_node(pydot.Node("test", label=string.printable)) data = g.create(format="jpe") assert len(data) > 0
def threadTree(self, graph, seen=None, col=0): colors = ('red', 'green', 'blue', 'yellow', 'magenta', 'cyan') if not seen: seen = [] if self in seen: return seen.append(self) new = not graph.get_node(self.ID) if new: graphnode = pydot.Node(self.ID, label=repr(self), shape=self.shape) graphnode.set_style('dotted') graph.add_node(graphnode) label = len(self.next) - 1 for i, c in enumerate(self.next): if not c: return col = (col + 1) % len(colors) col = 0 # FRT pour tout afficher en rouge color = colors[col] c.threadTree(graph, seen, col) edge = pydot.Edge(self.ID, c.ID) edge.set_color(color) edge.set_arrowsize('.5') # Les arr�tes correspondant aux coutures ne sont pas prises en compte # pour le layout du graphe. Ceci permet de garder l'arbre dans sa repr�sentation # "standard", mais peut provoquer des surprises pour le trajet parfois un peu # tarabiscot� des coutures... # En commantant cette ligne, le layout sera bien meilleur, mais l'arbre nettement # moins reconnaissable. edge.set_constraint('false') if label: edge.set_taillabel(str(i)) edge.set_labelfontcolor(color) graph.add_edge(edge) return graph
def plot_net(net, file_name='net.png', show_shapes=False, rankdir="TB"): dot = pydot.Dot() dot.set('rankdir', rankdir) dot.set('concentrate', True) dot.set_node_defaults(shape='recodr') id_layer_name_pair = dict() for i, layer in enumerate(net.all_layers): layer_name = layer.name layer_shape = layer.get_shape() if show_shapes: label = "%s\n %s" % (layer_name, str(layer_shape)) else: label = layer_name node = pydot.Node(i, label=label) dot.add_node(node) id_layer_name_pair[layer_name] = i for key in net.net_tree: if key in id_layer_name_pair.keys(): parent_id = id_layer_name_pair[key] else: continue for child in net.net_tree[key]: if child in id_layer_name_pair.keys(): child_id = id_layer_name_pair[child] dot.add_edge(pydot.Edge(parent_id,child_id)) _, extension = os.path.splitext(file_name) if not extension: extension = 'png' else: extension = extension[1:] dot.write(file_name, format=extension)
def _pydot_node_for_layer(self, layer, label): """ Returns the pydot.Node corresponding to the given layer. `label` specify the name of the layer (only used if the layer isn't yet associated with a pydot.Node) """ # Check if this already exists (will be the case for nodes that # serve as input to more than one layer) if layer in self.layer_to_pydotnode: node = self.layer_to_pydotnode[layer] else: layer_id = 'layer%d' % self.idgen self.idgen += 1 label = label + " (" + layer_typename(layer) + ")" if self.show_shape: # Build the label that will actually contain a table with the # input/output outputlabels = str(layer.output_shape) if hasattr(layer, 'input_shape'): inputlabels = str(layer.input_shape) elif hasattr(layer, 'input_shapes'): inputlabels = ', '.join( [str(ishape) for ishape in layer.input_shapes]) else: inputlabels = '' label = "%s\n|{input:|output:}|{{%s}|{%s}}" % ( label, inputlabels, outputlabels) node = pydot.Node(layer_id, label=label) self.g.add_node(node) self.layer_to_pydotnode[layer] = node return node
def to_pydot(N, strict=True): """Return a pydot graph from a NetworkX graph N. Parameters ---------- N : NetworkX graph A graph created with NetworkX Examples -------- >>> import networkx as nx >>> K5 = nx.complete_graph(5) >>> P = nx.to_pydot(K5) Notes ----- """ # set Graphviz graph type if N.is_directed(): graph_type = 'digraph' else: graph_type = 'graph' strict = N.number_of_selfloops() == 0 and not N.is_multigraph() name = N.graph.get('name') graph_defaults = N.graph.get('graph', {}) if name is None: P = pydot.Dot(graph_type=graph_type, strict=strict, **graph_defaults) else: P = pydot.Dot('"%s"' % name, graph_type=graph_type, strict=strict, **graph_defaults) try: P.set_node_defaults(**N.graph['node']) except KeyError: pass try: P.set_edge_defaults(**N.graph['edge']) except KeyError: pass for n, nodedata in N.nodes_iter(data=True): str_nodedata = dict((k, make_str(v)) for k, v in nodedata.items()) p = pydot.Node(make_str(n), **str_nodedata) P.add_node(p) if N.is_multigraph(): for u, v, key, edgedata in N.edges_iter(data=True, keys=True): str_edgedata = dict((k, make_str(v)) for k, v in edgedata.items()) edge = pydot.Edge(make_str(u), make_str(v), key=make_str(key), **str_edgedata) P.add_edge(edge) else: for u, v, edgedata in N.edges_iter(data=True): str_edgedata = dict((k, make_str(v)) for k, v in edgedata.items()) edge = pydot.Edge(make_str(u), make_str(v), **str_edgedata) P.add_edge(edge) return P
def make_graph(edges: list): graph = pydot.Dot(graph_type='digraph') # digraph有効グラフの指定 for edge in edges: id1 = edge[0][0] label1 = edge[0][1] id2 = edge[1][0] label2 = edge[1][1] # idがないと同じ文節が出たときに混ざってしまう graph.add_node(pydot.Node(id1, label=label1)) graph.add_node(pydot.Node(id2, label=label2)) # 上で追加したノードをつなぐエッジを追加、idで判断 graph.add_edge(pydot.Edge(id1, id2)) return graph
def test_add_style(self): node = pydot.Node('mynode') node.add_style('abc') self.assertEqual(node.get_style(), 'abc') node.add_style('def') self.assertEqual(node.get_style(), 'abc,def') node.add_style('ghi') self.assertEqual(node.get_style(), 'abc,def,ghi')
def graph_node(layers, dot, model, show_shapes=False, show_layer_names=False): for l, layer in enumerate(layers): layer_id = str(id(layer)) # Append a wrapped layer's label to node's label, if it exists. layer_name = layer.name class_name = layer.__class__.__name__ if class_name in [ "Dropout", "BatchNormalization", "Activation", "Flatten" ]: continue if class_name == "Model": layer.layers[0].inbound_nodes = layer.inbound_nodes graph_node(layer.layers, dot, layer, show_shapes=show_shapes) continue if isinstance(layer, Wrapper): layer_name = '{}({})'.format(layer_name, layer.layer.name) child_class_name = layer.layer.__class__.__name__ class_name = '{}({})'.format(class_name, child_class_name) # Create node's label. if show_layer_names: label = '{}: {}'.format(layer_name, class_name.split("(")[1][:-1]) else: label = class_name.split("(")[-1].split(")")[0] # Rebuild the label as a table including input/output shapes. if show_shapes: try: if len(layer.output_shape) > 2: outputlabels = str(layer.output_shape[2:]) else: outputlabels = str(layer.output_shape[1]) except: outputlabels = 'multiple' if hasattr(layer, 'input_shape'): if len(layer.input_shape) > 2: inputlabels = str(layer.input_shape[2:]) else: inputlabels = str(layer.input_shape[1]) elif hasattr(layer, 'input_shapes'): inputlabels = ', '.join( [str(ishape) for ishape in layer.input_shapes]) else: inputlabels = 'multiple' label = '%s\n|{input:|output:}|{{%s}|{%s}}' % (label, inputlabels, outputlabels) if "Convolution" in class_name: color = "red" elif "Pooling" in class_name: color = "blue" else: color = "green" node = pydot.Node(layer_id, label=label, color=color) dot.add_node(node)
def graph_from_edges_ex(edge_list, directed=False): ''' pydot_ng.graph_from_edges()のノード識別子への対応版 graph_from_edges()のedge_listで指定するタプルは 識別子とグラフ表示時のラベルが同一のため、 ラベルが同じだが実体が異なるノードを表現することができない。 例えば文の係り受けをグラフにする際、文の中に同じ単語が 複数出てくると、それらのノードが同一視されて接続されてしまう。 この関数ではedge_listとして次の書式のタプルを受け取り、 ラベルが同一でも識別子が異なるノードは別ものとして扱う。 edge_list = [((識別子1,ラベル1),(識別子2,ラベル2)), ...] 識別子はノードを識別するためのもので表示されない。 ラベルは表示用で、同じでも識別子が異なれば別のノードになる。 なお、オリジナルの関数にあるnode_prefixは未実装。 戻り値: pydot.Dotオブジェクト ''' 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]) # ノード追加 graph.add_node(pydot.Node(id1, label=label1)) graph.add_node(pydot.Node(id2, label=label2)) # エッジ追加 graph.add_edge(pydot.Edge(id1, id2)) return graph
def test_names_of_a_thousand_nodes(self): self._reset_graphs() names = set(['node_%05d' % i for i in xrange(10 ** 4)]) for name in names: self.graph_directed.add_node(pydot.Node(name, label=name)) self.assertEqual(set([n.get_name() for n in self.graph_directed.get_nodes()]), names)
def add_outputs(dot, model, max_outputs): # add outputs for node_name, output_node in model['outputs'].items(): source = output_node['node_index'] if len(output_node['labels']) > max_outputs: lab = node_name num = len(output_node['labels']) out_name = f'out_{source}_{lab}' dot.add_node(pydot.Node(out_name, label=lab + f'({num})')) dot.add_edge(pydot.Edge(str(source), out_name)) else: for lab in output_node['labels']: out_name = f'out_{source}_{lab}' dot.add_node(pydot.Node(out_name, label=lab)) dot.add_edge(pydot.Edge(str(source), out_name)) return dot
def make_graph(edges: list): graph = pydot.Dot(graph_type='digraph') for edge in edges: id1 = edge[0][0] label1 = edge[0][1] id2 = edge[1][0] label2 = edge[1][1] # print('{} {} {} {}\n'.format(id1, label1, id2, label2)) # ノードの追加 graph.add_node(pydot.Node(id1, label=label1)) graph.add_node(pydot.Node(id2, label=label2)) # 上で追加したノードをつなぐエッジを追加、idで判断 graph.add_edge(pydot.Edge(id1, id2)) return graph
def test_create_simple_graph_with_node(self): g = pydot.Dot() g.set_type('digraph') node = pydot.Node('legend') node.set("shape", 'box') g.add_node(node) node.set('label', 'mine') self.assertEqual(g.to_string(), 'digraph G {\nlegend [label=mine, shape=box];\n}\n')
def visualization(sentence): # 一応有向グラフも作る graph = pydot.Dot(graph_type='digraph') for source_chunk in sentence: s = pattern.sub("", source_chunk.morphstr) if "名詞" in [x.pos for x in source_chunk.morphs]: source_idx = source_chunk.index dst = source_chunk.dst # 名詞から最後まで辿る while dst != -1: s += " -> {}".format(pattern.sub("", sentence[dst].morphstr)) graph.add_node(pydot.Node(source_idx, label=pattern.sub("", sentence[source_idx].morphstr))) graph.add_node(pydot.Node(dst, label=pattern.sub("", sentence[dst].morphstr))) graph.add_edge(pydot.Edge(source_idx, dst)) source_idx = dst dst = sentence[dst].dst print(s) graph.write_png('knock48.png')
def test_graph_pickling(self): import pickle g = pydot.Graph() s = pydot.Subgraph("foo") g.add_subgraph(s) g.add_edge(pydot.Edge('A', 'B')) g.add_edge(pydot.Edge('A', 'C')) g.add_edge(pydot.Edge(('D', 'E'))) g.add_node(pydot.Node('node!')) self.assertEqual(type(pickle.dumps(g)), bytes)