Exemplo n.º 1
0
    def SaveGraph(self, filename):
        logging.debug("From SVNFileNetwork.SaveGraph")

        print "saving the file network graph to %s" % filename
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(self, prog='neato')
        print "finished layout"
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))
        NX.draw_networkx_nodes(self, pos, node_size=10)
        NX.draw_networkx_edges(self, pos)
        # display revision nodes in different colors
        revnodes = self.getNodes(SVNNetworkRevisionNode)
        NX.draw_networkx_nodes(
            self, pos, revnodes, node_color='g', node_size=30)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            self, pos, NX.center(self), node_color='b', node_size=50)

        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        self.PrintGraphStat()
        print "Saved ..."
Exemplo n.º 2
0
 def SaveGraph(self, filename):
     logging.debug("From SVNAuthorNetwork.SaveGraph")
     print "saving auhtor network graph to %s" % filename
     plt.clf()
     #
     dt1 = datetime.datetime.now()
     pos = NX.pydot_layout(self)
     #pos = NX.spring_layout(self, dim=2, iterations=10)
     dt2 = datetime.datetime.now()
     print "time of layout=%s" % (dt2 - dt1)
     plt.figure(figsize=(8.0, 8.0))
     nodeimgs = NX.draw_networkx_nodes(
         self, pos, with_labels=False, node_size=10)
     # set the urls for filenodes
     if (self._repoUrl != None):
         nodeUrls = []
         for node in self.nodes_iter():
             fileUrl = None
             if(isinstance(node, SVNNetworkFileNode) == True):
                 # File node add the URL
                 fileUrl = ''.join([self._repoUrl, node.name()])
             nodeUrls.append(fileUrl)
         nodeimgs.set_urls(nodeUrls)
     # Now draw edges
     NX.draw_networkx_edges(self, pos, with_labels=False)
     # draw author nodes with different color
     self._drawAuthorNodes(pos)
     plt.savefig(filename + '.svg', dpi=100, format="svg")
     plt.savefig(filename + '.png', dpi=100, format="png")
     print "Saved ..."
Exemplo n.º 3
0
    def SaveGraph(self, filename):
        logging.debug("From SVNFileNetwork.SaveGraph")

        print("saving the file network graph to %s" % filename)
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(self, prog='neato')
        print("finished layout")
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))
        NX.draw_networkx_nodes(self, pos, node_size=10)
        NX.draw_networkx_edges(self, pos)
        # display revision nodes in different colors
        revnodes = self.getNodes(SVNNetworkRevisionNode)
        NX.draw_networkx_nodes(
            self, pos, revnodes, node_color='g', node_size=30)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            self, pos, NX.center(self), node_color='b', node_size=50)

        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        self.PrintGraphStat()
        print("Saved ...")
Exemplo n.º 4
0
def draw_junction_tree(model, fnum=None, **kwargs):
    import plottool as pt
    fnum = pt.ensure_fnum(fnum)
    pt.figure(fnum=fnum)
    ax = pt.gca()
    from pgmpy.models import JunctionTree
    if not isinstance(model, JunctionTree):
        netx_graph = model.to_junction_tree()
    else:
        netx_graph = model
    # prettify nodes
    def fixtupkeys(dict_):
        return {
            ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v)
            for k, v in dict_.items()
        }
    n = fixtupkeys(netx_graph.node)
    e = fixtupkeys(netx_graph.edge)
    a = fixtupkeys(netx_graph.adj)
    netx_graph.node = n
    netx_graph.edge = e
    netx_graph.adj = a
    #netx_graph = model.to_markov_model()
    #pos = netx.pygraphviz_layout(netx_graph)
    #pos = netx.graphviz_layout(netx_graph)
    pos = netx.pydot_layout(netx_graph)
    node_color = [pt.NEUTRAL] * len(pos)
    drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color,
                  node_size=2000)
    netx.draw(netx_graph, **drawkw)
    if kwargs.get('show_title', True):
        pt.set_figtitle('Junction / Clique Tree / Cluster Graph')
Exemplo n.º 5
0
 def SaveGraph(self, filename):
     logging.debug("From SVNAuthorNetwork.SaveGraph")
     print("saving auhtor network graph to %s" % filename)
     plt.clf()
     #
     dt1 = datetime.datetime.now()
     pos = NX.pydot_layout(self)
     #pos = NX.spring_layout(self, dim=2, iterations=10)
     dt2 = datetime.datetime.now()
     print("time of layout=%s" % (dt2 - dt1))
     plt.figure(figsize=(8.0, 8.0))
     nodeimgs = NX.draw_networkx_nodes(
         self, pos, with_labels=False, node_size=10)
     # set the urls for filenodes
     if (self._repoUrl != None):
         nodeUrls = []
         for node in self.nodes_iter():
             fileUrl = None
             if(isinstance(node, SVNNetworkFileNode) == True):
                 # File node add the URL
                 fileUrl = ''.join([self._repoUrl, node.name()])
             nodeUrls.append(fileUrl)
         nodeimgs.set_urls(nodeUrls)
     # Now draw edges
     NX.draw_networkx_edges(self, pos, with_labels=False)
     # draw author nodes with different color
     self._drawAuthorNodes(pos)
     plt.savefig(filename + '.svg', dpi=100, format="svg")
     plt.savefig(filename + '.png', dpi=100, format="png")
     print("Saved ...")
Exemplo n.º 6
0
def draw_tree_model(model, **kwargs):
    import plottool as pt
    import networkx as netx
    if not ut.get_argval('--hackjunc'):
        fnum = pt.ensure_fnum(None)
        fig = pt.figure(fnum=fnum, doclf=True)  # NOQA
        ax = pt.gca()
        #name_nodes = sorted(ut.list_getattr(model.ttype2_cpds['name'], 'variable'))
        netx_graph = model.to_markov_model()
        #pos = netx.pygraphviz_layout(netx_graph)
        #pos = netx.graphviz_layout(netx_graph)
        #pos = get_hacked_pos(netx_graph, name_nodes, prog='neato')
        pos = netx.pydot_layout(netx_graph)
        node_color = [pt.WHITE] * len(pos)
        drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color,
                      node_size=1100)
        netx.draw(netx_graph, **drawkw)
        if kwargs.get('show_title', True):
            pt.set_figtitle('Markov Model')

    if not ut.get_argval('--hackmarkov'):
        fnum = pt.ensure_fnum(None)
        fig = pt.figure(fnum=fnum, doclf=True)  # NOQA
        ax = pt.gca()
        netx_graph = model.to_junction_tree()
        # prettify nodes
        def fixtupkeys(dict_):
            return {
                ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v)
                for k, v in dict_.items()
            }
        n = fixtupkeys(netx_graph.node)
        e = fixtupkeys(netx_graph.edge)
        a = fixtupkeys(netx_graph.adj)
        netx_graph.node = n
        netx_graph.edge = e
        netx_graph.adj = a
        #netx_graph = model.to_markov_model()
        #pos = netx.pygraphviz_layout(netx_graph)
        #pos = netx.graphviz_layout(netx_graph)
        pos = netx.pydot_layout(netx_graph)
        node_color = [pt.WHITE] * len(pos)
        drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color,
                      node_size=2000)
        netx.draw(netx_graph, **drawkw)
        if kwargs.get('show_title', True):
            pt.set_figtitle('Junction/Clique Tree / Cluster Graph')
Exemplo n.º 7
0
def draw(graph):
    """Draw the *graph*"""
    nx.draw(graph,
            pos=nx.pydot_layout(graph),
            node_size=1,
            node_color='w',
            font_size=8)
    plt.show()
Exemplo n.º 8
0
 def draw(self):
     try:
         pydot_layout = nx.nx_pydot.pydot_layout
         draw_networkx = nx.draw_networkx()
         pos = nx.pydot_layout(self, prog='dot')
         nx.draw_networkx(self, pos, labels=self._labels, edgelist=[])
         nx.draw_networkx_edges(self, pos)
     except:
         pass
Exemplo n.º 9
0
 def draw(self):
     try:
         pydot_layout = nx.nx_pydot.pydot_layout
         draw_networkx = nx.draw_networkx()
         pos = nx.pydot_layout(self, prog='dot')
         nx.draw_networkx(self, pos, labels=self._labels, edgelist=[])
         nx.draw_networkx_edges(self, pos)
     except:
         pass
Exemplo n.º 10
0
 def draw(self):
     try:
         pydot_layout = nx.nx_pydot.pydot_layout
         draw_networkx = nx.draw_networkx()
         pos = nx.pydot_layout(self, prog='dot')
         nx.draw_networkx(self, pos, labels=self._labels, edgelist=[])
         nx.draw_networkx_edges(self, pos, edgelist=self.principal_edges())
         nx.draw_networkx_edges(self, pos, edgelist=self.secondary_edges(), style='dashed')
     except:
         pass
Exemplo n.º 11
0
 def draw(self):
     try:
         pydot_layout = nx.nx_pydot.pydot_layout
         draw_networkx = nx.draw_networkx()
         pos = nx.pydot_layout(self, prog='dot')
         nx.draw_networkx(self, pos, labels=self._labels, edgelist=[])
         nx.draw_networkx_edges(self, pos, edgelist=self.principal_edges())
         nx.draw_networkx_edges(self,
                                pos,
                                edgelist=self.secondary_edges(),
                                style='dashed')
     except:
         pass
Exemplo n.º 12
0
	def plotSFGOTree(self, sf, terms):
		dag = GODAG(nodes=terms)
		#print "Loading edges"
		dag.load_edges(self.mygo_conn)
		node_color = {}
		for node in dag.nodes():
			node_color[_pydot(node)] = self.prob_metric.get_metric("all",node) 
		node_size = {}
		for node in dag.nodes():
			node_size[_pydot(node)] = 50 + self.prob_metric.get_metric(sf, node) * 1000 
		#print dag.nodes()
		graph = dag.graph()
		#print graph.nodes()
		labels = {}
		for node in graph.nodes():
			labels[node] = "GO:"+node.acc+"\n"+node.name
			
		# Now add the ruler
		rang = range(11)
		rang.reverse()
		base_prob =  [n*0.1 for n in rang]
		base_lab = ["%i" % int(n*10) for n in base_prob]
		for i,l in enumerate(base_lab):
			node_color[l] = base_prob[i]
			node_size[l] = 50 + base_prob[i]*1000
			labels[l] = "0."+l if l != "10" else "1"
			graph.add_node(l)
			if i < 10:
				graph.add_edge(l,base_lab[i+1])
		#print graph.nodes()
		
		pos = nx.pydot_layout(graph, prog="dot")
		matplotlib.pyplot.figure(figsize=(10, 10))
		nx.draw(graph,
			    font_size=8,
			    labels=labels,
			    pos=pos,
			    cmap="autumn",
			    node_color=[node_color[n] for n in graph.nodes()],
			    node_size=[node_size[n] for n in graph.nodes()],
			    with_labels=True)
		f_parts = self.sf_func_plot_filename.rpartition('.')
		filename = f_parts[0] + "_" + sf + "_go_" + "." + f_parts[2]
		matplotlib.pyplot.savefig(filename)
Exemplo n.º 13
0
    def SaveMST(self, filename):
        logging.debug("From SVNFileNetwork.SaveMST")

        mstGraph = self._getMSTGraph()

        print "saving MST of the file network graph to %s" % filename
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(mstGraph, prog='neato')
        print "finished layout"
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))

        NX.draw_networkx_nodes(mstGraph, pos, node_size=10)
        NX.draw_networkx_edges(mstGraph, pos)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            mstGraph, pos, NX.center(mstGraph), node_color='b', node_size=50)
        # create node labels
        label = dict()
        for node in mstGraph.nodes_iter():
            dirname, fname = os.path.split(node.name())
            label[node] = fname
        NX.draw_networkx_labels(mstGraph, pos, label, font_size=8)

        # disable X and Y tick labels
        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        print "Saved MST..."
        print "saving MST treemap"
        jsfilename, ext = os.path.splitext(filename)
        jsfilename = jsfilename + '.js'
        print "treemap filename %s" % jsfilename
        outfile = open(jsfilename, "w")
        self.treemapNodeDict['Root'].writejson(
            outfile, 'closeness', 'betweenness')
        outfile.close()
Exemplo n.º 14
0
    def SaveMST(self, filename):
        logging.debug("From SVNFileNetwork.SaveMST")

        mstGraph = self._getMSTGraph()

        print("saving MST of the file network graph to %s" % filename)
        plt.clf()
        #pos = NX.spring_layout(self, dim=2, iterations=20)
        logging.info("starting layout using pydot_layout")
        pos = NX.pydot_layout(mstGraph, prog='neato')
        print("finished layout")
        logging.info("finished layout using pydot_layout")
        plt.figure(figsize=(8.0, 8.0))

        NX.draw_networkx_nodes(mstGraph, pos, node_size=10)
        NX.draw_networkx_edges(mstGraph, pos)
        # display center nodes with larger size
        NX.draw_networkx_nodes(
            mstGraph, pos, NX.center(mstGraph), node_color='b', node_size=50)
        # create node labels
        label = dict()
        for node in mstGraph.nodes_iter():
            dirname, fname = os.path.split(node.name())
            label[node] = fname
        NX.draw_networkx_labels(mstGraph, pos, label, font_size=8)

        # disable X and Y tick labels
        ax = plt.gca()
        plt.setp(ax.get_yticklabels(), visible=False)
        plt.setp(ax.get_xticklabels(), visible=False)

        plt.savefig(filename, dpi=100, format="png")
        print("Saved MST...")
        print("saving MST treemap")
        jsfilename, ext = os.path.splitext(filename)
        jsfilename = jsfilename + '.js'
        print("treemap filename %s" % jsfilename)
        outfile = open(jsfilename, "w")
        self.treemapNodeDict['Root'].writejson(
            outfile, 'closeness', 'betweenness')
        outfile.close()
Exemplo n.º 15
0
def draw_junction_tree(model, fnum=None, **kwargs):
    import wbia.plottool as pt

    fnum = pt.ensure_fnum(fnum)
    pt.figure(fnum=fnum)
    ax = pt.gca()
    from pgmpy.models import JunctionTree

    if not isinstance(model, JunctionTree):
        netx_graph = model.to_junction_tree()
    else:
        netx_graph = model
    # prettify nodes

    def fixtupkeys(dict_):
        return {
            ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v)
            for k, v in dict_.items()
        }

    n = fixtupkeys(netx_graph.nodes)
    e = fixtupkeys(netx_graph.edge)
    a = fixtupkeys(netx_graph.adj)
    netx_graph.nodes = n
    netx_graph.edge = e
    netx_graph.adj = a
    # netx_graph = model.to_markov_model()
    # pos = nx.nx_agraph.pygraphviz_layout(netx_graph)
    # pos = nx.nx_agraph.graphviz_layout(netx_graph)
    pos = nx.pydot_layout(netx_graph)
    node_color = [pt.NEUTRAL] * len(pos)
    drawkw = dict(pos=pos,
                  ax=ax,
                  with_labels=True,
                  node_color=node_color,
                  node_size=2000)
    nx.draw(netx_graph, **drawkw)
    if kwargs.get('show_title', True):
        pt.set_figtitle('Junction / Clique Tree / Cluster Graph')
Exemplo n.º 16
0
 def draw(self):
     pos = nx.pydot_layout(self,prog='dot')
     nx.draw_networkx(self, pos, labels = self._labels, edgelist=[])
     nx.draw_networkx_edges(self, pos, edgelist = self.principal_edges())
     nx.draw_networkx_edges(self, pos, edgelist = self.secondary_edges(), style = 'dashed')
Exemplo n.º 17
0
 def draw(self):
     pos = nx.pydot_layout(self,prog='dot')
     nx.draw_networkx(self, pos, labels = self._labels, edgelist=[])
     nx.draw_networkx_edges(self, pos)
Exemplo n.º 18
0
def draw(graph):
    """Draw the *graph*"""
    nx.draw(graph, pos = nx.pydot_layout(graph), node_size = 1, node_color = 'w', font_size = 8)
    plt.show()
Exemplo n.º 19
0
def plotIt():
    prob = Probability()
    prob.set_metric("a.1.1","A",1.0)
    prob.set_metric("a.1.1","B",0.83)
    prob.set_metric("a.1.1","C",0.84)
    prob.set_metric("a.1.1","D",0.1)
    prob.set_metric("a.1.1","E",0.01)
    prob.set_metric("a.1.1","Z",0.01)
    prob.set_metric("a.1.1","Y",0.01)
    prob.set_metric("a.1.1","X",0.01)
    prob.set_metric("a.1.1","W",0.01)
    prob.set_metric("a.1.1","V",0.01)
    prob.set_metric("a.1.1","U",0.01)
    prob.set_metric("a.1.1","T",0.01)
    prob.set_metric("a.1.1","S",0.01)
    prob.set_metric("a.1.1","R",0.01)
    prob.set_metric("a.1.1","Q",0.01)
    prob.set_metric("a.1.1","P",0.01)
    prob.set_metric("A",None,1.0)
    prob.set_metric("B",None,0.8)
    prob.set_metric("C",None,0.8)
    prob.set_metric("D",None,0.1)
    prob.set_metric("E",None,0.01)
    prob.set_metric("Z",None,1.0)
    prob.set_metric("Y",None,0.9)
    prob.set_metric("X",None,0.8)
    prob.set_metric("W",None,0.7)
    prob.set_metric("V",None,0.6)
    prob.set_metric("U",None,0.5)
    prob.set_metric("T",None,0.4)
    prob.set_metric("S",None,0.3)
    prob.set_metric("R",None,0.2)
    prob.set_metric("Q",None,0.1)
    prob.set_metric("P",None,0.0)

    nbunch = [(Term(m,"name"),prob.get_metric(sf,m)) for sf,m in prob if sf != None and m!= None]
    ebunch = [(Term("A"),Term("B")),
              (Term("A"),Term("C")),
              (Term("C"),Term("D")),
              (Term("D"),Term("E")),
              (Term("Z"),Term("Y")),
              (Term("Y"),Term("X")),
              (Term("X"),Term("W")),
              (Term("W"),Term("V")),
              (Term("V"),Term("U")),
              (Term("U"),Term("T")),
              (Term("T"),Term("S")),
              (Term("S"),Term("R")),
              (Term("R"),Term("Q")),
              (Term("Q"),Term("P")),]
    dag = GODAG(nbunch=nbunch,ebunch=ebunch)
    print dag.graph.nodes()
    matplotlib.pyplot.figure(figsize=(5, 5))
    # with nodes colored by degree sized by population
    node_color=[float(prob.get_metric(node.get_id(),None)) for node in dag.graph.nodes()]
    pos = nx.pydot_layout(dag.graph,prog="dot")
    labels = {}
    for node in dag.graph.nodes():
        labels[node] = node.acc+"\n"+node.name
    nx.draw(dag.graph,
            font_size=8,
            labels=labels,
            pos=pos,
            cmap="autumn",
            node_color=node_color,
            node_size=[50+prob.get_metric("a.1.1",node)*1000 for node, data in dag.graph.nodes(data=True)],
            #node_size=[100 for node, data in dag.graph.nodes(data=True)],
            with_labels=True)
    # scale the axes equally
    #matplotlib.pyplot.xlim(-5000, 500)
    #matplotlib.pyplot.ylim(-2000, 3500)
    filename = "/home/patrick/Sites/testGO.png"
    matplotlib.pyplot.savefig(filename)
Exemplo n.º 20
0
				if bib_graph.get_edge_data(clean_author_handle, clean_next_author_handle, default=0):
					bib_graph[clean_author_handle][clean_next_author_handle]['weight'] = bib_graph[clean_author_handle][clean_next_author_handle]['weight'] + 1
				else:
					bib_graph.add_edge(clean_author_handle, clean_next_author_handle, weight = 1)
		
	node_weight=[]
	edge_weight = [data.values()[0] for a,b,data in bib_graph.edges(data=True)]
	for n in range(0,len(bib_graph)):
		node_weight.append(0)
		for e in nx.edges_iter(bib_graph, bib_graph.nodes()[n]):
			node_weight[n] = node_weight[n] + bib_graph.get_edge_data(e[0],e[1]).values()[0]
	node_weight = [n*2.5 for n in node_weight]
	
	fig = plt.figure(1, figsize=(8, 8))
	if year_iter == max_year_input:
		init_pos=nx.pydot_layout(bib_graph)
	for node in bib_graph:
		pos[node] = init_pos[node]
	nx.draw_networkx(bib_graph, pos, node_size=node_weight, node_color=node_weight, edge_color=edge_weight, cmap=plt.cm.OrRd, font_size=9)
	
	if year_iter == max_year_input:
		xmax=max(xx for xx,yy in pos.values())
		xmin=min(xx for xx,yy in pos.values())
		ymax=max(yy for xx,yy in pos.values())
		ymin=min(yy for xx,yy in pos.values())
		dx = xmax - xmin
		ddx=0.1*dx
		dy = ymax - ymin
		ddy=0.1*dy
	plt.hold(False)
	plt.xlim(xmin-ddx,xmax+ddx)
Exemplo n.º 21
0
def bayesnet():
    """
    References:
        https://class.coursera.org/pgm-003/lecture/17
        http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
        http://www3.cs.stonybrook.edu/~sael/teaching/cse537/Slides/chapter14d_BP.pdf
        http://www.cse.unsw.edu.au/~cs9417ml/Bayes/Pages/PearlPropagation.html
        https://github.com/pgmpy/pgmpy.git
        http://pgmpy.readthedocs.org/en/latest/
        http://nipy.bic.berkeley.edu:5000/download/11
    """
    # import operator as op
    # # Enumerate all possible events
    # varcard_list = list(map(op.attrgetter('variable_card'), cpd_list))
    # _esdat = list(ut.iprod(*map(range, varcard_list)))
    # _escol = list(map(op.attrgetter('variable'), cpd_list))
    # event_space = pd.DataFrame(_esdat, columns=_escol)

    # # Custom compression of event space to inspect a specific graph
    # def compress_space_flags(event_space, var1, var2, var3, cmp12_):
    #     """
    #     var1, var2, cmp_ = 'Lj', 'Lk', op.eq
    #     """
    #     import vtool as vt
    #     data = event_space
    #     other_cols = ut.setdiff_ordered(data.columns.tolist(), [var1, var2, var3])
    #     case_flags12 = cmp12_(data[var1], data[var2]).values
    #     # case_flags23 = cmp23_(data[var2], data[var3]).values
    #     # case_flags = np.logical_and(case_flags12, case_flags23)
    #     case_flags = case_flags12
    #     case_flags = case_flags.astype(np.int64)
    #     subspace = np.hstack((case_flags[:, None], data[other_cols].values))
    #     sel_ = vt.unique_row_indexes(subspace)
    #     flags = np.logical_and(mask, case_flags)
    #     return flags

    # # Build special cases
    # case_same   = event_space.loc[compress_space_flags(event_space, 'Li', 'Lj', 'Lk', op.eq)]
    # case_diff = event_space.loc[compress_space_flags(event_space, 'Li', 'Lj', 'Lk', op.ne)]
    # special_cases = [
    #     case_same,
    #     case_diff,
    # ]

    from pgmpy.factors import TabularCPD
    from pgmpy.models import BayesianModel
    import pandas as pd
    from pgmpy.inference import BeliefPropagation  # NOQA
    from pgmpy.inference import VariableElimination  # NOQA

    name_nice = ['n1', 'n2', 'n3']
    score_nice = ['low', 'high']
    match_nice = ['diff', 'same']
    num_names = len(name_nice)
    num_scores = len(score_nice)
    nid_basis = list(range(num_names))
    score_basis = list(range(num_scores))

    semtype2_nice = {
        'score': score_nice,
        'name': name_nice,
        'match': match_nice,
    }
    var2_cpd = {
    }
    globals()['semtype2_nice'] = semtype2_nice
    globals()['var2_cpd'] = var2_cpd

    name_combo = np.array(list(ut.iprod(nid_basis, nid_basis)))
    combo_is_same = name_combo.T[0] == name_combo.T[1]
    def get_expected_scores_prob(level1, level2):
        part1 = combo_is_same * level1
        part2 = (1 - combo_is_same) * (1 - (level2))
        expected_scores_level = part1 + part2
        return expected_scores_level

    # def make_cpd():

    def name_cpd(aid):
        from pgmpy.factors import TabularCPD
        cpd = TabularCPD(
            variable='N' + aid,
            variable_card=num_names,
            values=[[1.0 / num_names] * num_names])
        cpd.semtype = 'name'
        return cpd

    name_cpds = [name_cpd('i'), name_cpd('j'), name_cpd('k')]
    var2_cpd.update(dict(zip([cpd.variable for cpd in name_cpds], name_cpds)))
    if True:
        num_same_diff = 2
        samediff_measure = np.array([
            # get_expected_scores_prob(.12, .2),
            # get_expected_scores_prob(.88, .8),
            get_expected_scores_prob(0, 0),
            get_expected_scores_prob(1, 1),
        ])
        samediff_vals = (samediff_measure / samediff_measure.sum(axis=0)).tolist()
        def samediff_cpd(aid1, aid2):
            cpd = TabularCPD(
                variable='A' + aid1 + aid2,
                variable_card=num_same_diff,
                values=samediff_vals,
                evidence=['N' + aid1, 'N' + aid2],  # [::-1],
                evidence_card=[num_names, num_names])  # [::-1])
            cpd.semtype = 'match'
            return cpd
        samediff_cpds = [samediff_cpd('i', 'j'), samediff_cpd('j', 'k'), samediff_cpd('k', 'i')]
        var2_cpd.update(dict(zip([cpd.variable for cpd in samediff_cpds], samediff_cpds)))

        if True:
            def score_cpd(aid1, aid2):
                semtype = 'score'
                evidence = ['A' + aid1 + aid2, 'N' + aid1, 'N' + aid2]
                evidence_cpds = [var2_cpd[key] for key in evidence]
                evidence_nice = [semtype2_nice[cpd.semtype] for cpd in evidence_cpds]
                evidence_card = list(map(len, evidence_nice))
                evidence_states = list(ut.iprod(*evidence_nice))
                variable_basis = semtype2_nice[semtype]

                variable_values = []
                for mystate in variable_basis:
                    row = []
                    for state in evidence_states:
                        if state[0] == state[1]:
                            if state[2] == 'same':
                                val = .2 if mystate == 'low' else .8
                            else:
                                val = 1
                                # val = .5 if mystate == 'low' else .5
                        elif state[0] != state[1]:
                            if state[2] == 'same':
                                val = .5 if mystate == 'low' else .5
                            else:
                                val = 1
                                # val = .9 if mystate == 'low' else .1
                        row.append(val)
                    variable_values.append(row)

                cpd = TabularCPD(
                    variable='S' + aid1 + aid2,
                    variable_card=len(variable_basis),
                    values=variable_values,
                    evidence=evidence,  # [::-1],
                    evidence_card=evidence_card)  # [::-1])
                cpd.semtype = semtype
                return cpd
        else:
            score_values = [
                [.8, .1],
                [.2, .9],
            ]
            def score_cpd(aid1, aid2):
                cpd = TabularCPD(
                    variable='S' + aid1 + aid2,
                    variable_card=num_scores,
                    values=score_values,
                    evidence=['A' + aid1 + aid2],  # [::-1],
                    evidence_card=[num_same_diff])  # [::-1])
                cpd.semtype = 'score'
                return cpd

        score_cpds = [score_cpd('i', 'j'), score_cpd('j', 'k')]
        cpd_list = name_cpds + score_cpds + samediff_cpds
    else:
        score_measure = np.array([get_expected_scores_prob(level1, level2)
                                  for level1, level2 in
                                  zip(np.linspace(.1, .9, num_scores),
                                      np.linspace(.2, .8, num_scores))])

        score_values = (score_measure / score_measure.sum(axis=0)).tolist()

        def score_cpd(aid1, aid2):
            cpd = TabularCPD(
                variable='S' + aid1 + aid2,
                variable_card=num_scores,
                values=score_values,
                evidence=['N' + aid1, 'N' + aid2],
                evidence_card=[num_names, num_names])
            cpd.semtype = 'score'
            return cpd
        score_cpds = [score_cpd('i', 'j'), score_cpd('j', 'k')]
        cpd_list = name_cpds + score_cpds
        pass

    input_graph = []
    for cpd in cpd_list:
        if cpd.evidence is not None:
            for evar in cpd.evidence:
                input_graph.append((evar, cpd.variable))
    name_model = BayesianModel(input_graph)
    name_model.add_cpds(*cpd_list)

    var2_cpd.update(dict(zip([cpd.variable for cpd in cpd_list], cpd_list)))
    globals()['var2_cpd'] = var2_cpd

    varnames = [cpd.variable for cpd in cpd_list]

    # --- PRINT CPDS ---

    cpd = score_cpds[0]
    def print_cpd(cpd):
        print('CPT: %r' % (cpd,))
        index = semtype2_nice[cpd.semtype]
        if cpd.evidence is None:
            columns = ['None']
        else:
            basis_lists = [semtype2_nice[var2_cpd[ename].semtype] for ename in cpd.evidence]
            columns = [','.join(x) for x in ut.iprod(*basis_lists)]
        data = cpd.get_cpd()
        print(pd.DataFrame(data, index=index, columns=columns))

    for cpd in name_model.get_cpds():
        print('----')
        print(cpd._str('phi'))
        print_cpd(cpd)

    # --- INFERENCE ---

    Ni = name_cpds[0]

    event_space_combos = {}
    event_space_combos[Ni.variable] = 0  # Set ni to always be Fred
    for cpd in cpd_list:
        if cpd.semtype == 'score':
            event_space_combos[cpd.variable] = list(range(cpd.variable_card))
    evidence_dict = ut.all_dict_combinations(event_space_combos)

    # Query about name of annotation k given different event space params

    def pretty_evidence(evidence):
        return [key + '=' + str(semtype2_nice[var2_cpd[key].semtype][val])
                for key, val in evidence.items()]

    def print_factor(factor):
        row_cards = factor.cardinality
        row_vars = factor.variables
        values = factor.values.reshape(np.prod(row_cards), 1).flatten()
        # col_cards = 1
        # col_vars = ['']
        basis_lists = list(zip(*list(ut.iprod(*[range(c) for c in row_cards]))))
        nice_basis_lists = []
        for varname, basis in zip(row_vars, basis_lists):
            cpd = var2_cpd[varname]
            _nice_basis = ut.take(semtype2_nice[cpd.semtype], basis)
            nice_basis = ['%s=%s' % (varname, val) for val in _nice_basis]
            nice_basis_lists.append(nice_basis)
        row_lbls = [', '.join(sorted(x)) for x in zip(*nice_basis_lists)]
        print(ut.repr3(dict(zip(row_lbls, values)), precision=3, align=True, key_order_metric='-val'))

    # name_belief = BeliefPropagation(name_model)
    name_belief = VariableElimination(name_model)
    import pgmpy
    import six  # NOQA

    def try_query(evidence):
        print('--------')
        query_vars = ut.setdiff_ordered(varnames, list(evidence.keys()))
        evidence_str = ', '.join(pretty_evidence(evidence))
        probs = name_belief.query(query_vars, evidence)
        factor_list = probs.values()
        joint_factor = pgmpy.factors.factor_product(*factor_list)
        print('P(' + ', '.join(query_vars) + ' | ' + evidence_str + ')')
        # print(six.text_type(joint_factor))
        factor = joint_factor  # NOQA
        # print_factor(factor)
        # import utool as ut
        print(ut.hz_str([(f._str(phi_or_p='phi')) for f in factor_list]))

    for evidence in evidence_dict:
        try_query(evidence)

    evidence = {'Aij': 1, 'Ajk': 1, 'Aki': 1, 'Ni': 0}
    try_query(evidence)

    evidence = {'Aij': 0, 'Ajk': 0, 'Aki': 0, 'Ni': 0}
    try_query(evidence)

    globals()['score_nice'] = score_nice
    globals()['name_nice'] = name_nice
    globals()['score_basis'] = score_basis
    globals()['nid_basis'] = nid_basis

    print('Independencies')
    print(name_model.get_independencies())
    print(name_model.local_independencies([Ni.variable]))

    # name_belief = BeliefPropagation(name_model)
    # # name_belief = VariableElimination(name_model)
    # for case in special_cases:
    #     test_data = case.drop('Lk', axis=1)
    #     test_data = test_data.reset_index(drop=True)
    #     print('----')
    #     for i in range(test_data.shape[0]):
    #         evidence = test_data.loc[i].to_dict()
    #         probs = name_belief.query(['Lk'], evidence)
    #         factor = probs['Lk']
    #         probs = factor.values
    #         evidence_ = evidence.copy()
    #         evidence_['Li'] = name_nice[evidence['Li']]
    #         evidence_['Lj'] = name_nice[evidence['Lj']]
    #         evidence_['Sij'] = score_nice[evidence['Sij']]
    #         evidence_['Sjk'] = score_nice[evidence['Sjk']]
    #         nice2_prob = ut.odict(zip(name_nice, probs.tolist()))
    #         ut.print_python_code('P(Lk | {evidence}) = {cpt}'.format(
    #             evidence=(ut.repr2(evidence_, explicit=True, nobraces=True, strvals=True)),
    #             cpt=ut.repr3(nice2_prob, precision=3, align=True, key_order_metric='-val')
    #         ))

    # for case in special_cases:
    #     test_data = case.drop('Lk', axis=1)
    #     test_data = test_data.drop('Lj', axis=1)
    #     test_data = test_data.reset_index(drop=True)
    #     print('----')
    #     for i in range(test_data.shape[0]):
    #         evidence = test_data.loc[i].to_dict()
    #         query_vars = ['Lk', 'Lj']
    #         probs = name_belief.query(query_vars, evidence)
    #         for queryvar in query_vars:
    #             factor = probs[queryvar]
    #             print(factor._str('phi'))
    #             probs = factor.values
    #             evidence_ = evidence.copy()
    #             evidence_['Li'] = name_nice[evidence['Li']]
    #             evidence_['Sij'] = score_nice[evidence['Sij']]
    #             evidence_['Sjk'] = score_nice[evidence['Sjk']]
    #             nice2_prob = ut.odict(zip([queryvar + '=' + x for x in name_nice], probs.tolist()))
    #             ut.print_python_code('P({queryvar} | {evidence}) = {cpt}'.format(
    #                 query_var=query_var,
    #                 evidence=(ut.repr2(evidence_, explicit=True, nobraces=True, strvals=True)),
    #                 cpt=ut.repr3(nice2_prob, precision=3, align=True, key_order_metric='-val')
    #             ))

    # _ draw model

    import plottool as pt
    import networkx as netx
    fig = pt.figure()  # NOQA
    fig.clf()
    ax = pt.gca()

    netx_nodes = [(node, {}) for node in name_model.nodes()]
    netx_edges = [(etup[0], etup[1], {}) for etup in name_model.edges()]
    netx_graph = netx.DiGraph()
    netx_graph.add_nodes_from(netx_nodes)
    netx_graph.add_edges_from(netx_edges)

    # pos = netx.graphviz_layout(netx_graph)
    pos = netx.pydot_layout(netx_graph, prog='dot')
    netx.draw(netx_graph, pos=pos, ax=ax, with_labels=True)

    pt.plt.savefig('foo.png')
    ut.startfile('foo.png')
Exemplo n.º 22
0
        bib_graph.node[n]['weight'] = temp_node_weight

    node_weight = [
        data.values()[0] * 2.5 for n, data in bib_graph.nodes(data=True)
    ]
    edge_weight = [
        data.values()[0] for a, b, data in bib_graph.edges(data=True)
    ]

    data = json_graph.node_link_data(bib_graph)
    json_output_file = open("../output/json-graph%s.json" % year_iter, 'w')
    json_output_file.write(str(data))

    fig = plt.figure(1, figsize=(8, 8))
    if year_iter == max_year_input:
        init_pos = nx.pydot_layout(bib_graph)
    for node in bib_graph:
        pos[node] = init_pos[node]
    nx.draw_networkx(bib_graph,
                     pos,
                     node_size=node_weight,
                     node_color=node_weight,
                     edge_color=edge_weight,
                     cmap=plt.cm.OrRd,
                     font_size=9)

    if year_iter == max_year_input:
        xmax = max(xx for xx, yy in pos.values())
        xmin = min(xx for xx, yy in pos.values())
        ymax = max(yy for xx, yy in pos.values())
        ymin = min(yy for xx, yy in pos.values())
Exemplo n.º 23
0
import networkx as nx
import pydot

#g = nx.readwrite.gexf.read_gexf("baseline98_anim.gexf")
g = nx.readwrite.graphml.read_graphml("baseline98_anim.graphml")

print "Read in graph with nodes: "+str(len(g.nodes()))

##  For specifying a subgraph
layout_nodes = []
for a,b,d in g.edges_iter(data=True):
    if int(d["day"]) < 35:
        layout_nodes.append(a)
        layout_nodes.append(b)
print "Grabbed "+str(len(layout_nodes))+" nodes to subgraph and layout"

s = g.subgraph(layout_nodes)
nx.readwrite.graphml.write_graphml(s,"baseline98_under35.graphml")



pos = nx.pydot_layout(s,prog="sfdp")
        


Exemplo n.º 24
0
# We aren't done yet, need to add outer most layer to graph
outer_hit_ids = []
for row in hits_response:
    if (int(row[3]) == max_iter):
        outer_hit_ids.append(str(row[1]))

# get results of those hit ids and add them to the graph
for hit_id in outer_hit_ids:
    db.execute("select Response from results where Hit_ID = ?", [hit_id])
    responses = db.fetchall()
    for phrase in responses:
        G.add_edge(str(hits_set[hit_id][0]), str(phrase[0]))

#for g in G:
#	print g
graph_pos = nx.pydot_layout(G)

graph_layout='shell'
node_size=0
node_color='blue'
node_alpha=0.3
node_text_size=15
node_text_color = 'black'
node_text_weight = 'bold'
edge_color='white'
edge_alpha=0.5
edge_tickness=2
edge_text_pos=0.3
text_font='sans-serif'

nx.draw_networkx_nodes(G,graph_pos,node_size=node_size, 
Exemplo n.º 25
0
def draw_graphviz(tree, label_func=str, prog='twopi', args='',
        node_color='#c0deff', **kwargs):
    """Display a tree or clade as a graph, using the graphviz engine.

    Requires NetworkX, matplotlib, Graphviz and either PyGraphviz or pydot.

    The third and fourth parameters apply to Graphviz, and the remaining
    arbitrary keyword arguments are passed directly to networkx.draw(), which
    in turn mostly wraps matplotlib/pylab.  See the documentation for Graphviz
    and networkx for detailed explanations.

    The NetworkX/matplotlib parameters are described in the docstrings for
    networkx.draw() and pylab.scatter(), but the most reasonable options to try
    are: *alpha, node_color, node_size, node_shape, edge_color, style,
    font_size, font_color, font_weight, font_family*

    :Parameters:

        label_func : callable
            A function to extract a label from a node. By default this is str(),
            but you can use a different function to select another string
            associated with each node. If this function returns None for a node,
            no label will be shown for that node.

            The label will also be silently skipped if the throws an exception
            related to ordinary attribute access (LookupError, AttributeError,
            ValueError); all other exception types will still be raised. This
            means you can use a lambda expression that simply attempts to look
            up the desired value without checking if the intermediate attributes
            are available:

                >>> Phylo.draw_graphviz(tree, lambda n: n.taxonomies[0].code)

        prog : string
            The Graphviz program to use when rendering the graph. 'twopi'
            behaves the best for large graphs, reliably avoiding crossing edges,
            but for moderate graphs 'neato' looks a bit nicer.  For small
            directed graphs, 'dot' may produce the most normal-looking
            phylogram, but will cross and distort edges in larger graphs. (The
            programs 'circo' and 'fdp' are not recommended.)
        args : string
            Options passed to the external graphviz program.  Normally not
            needed, but offered here for completeness.

    Example
    -------

    >>> import pylab
    >>> from Bio import Phylo
    >>> tree = Phylo.read('ex/apaf.xml', 'phyloxml')
    >>> Phylo.draw_graphviz(tree)
    >>> pylab.show()
    >>> pylab.savefig('apaf.png')
    """
    try:
        import networkx
    except ImportError:
        from Bio import MissingPythonDependencyError
        raise MissingPythonDependencyError(
                "Install NetworkX if you want to use to_networkx.")

    G = to_networkx(tree)
    Gi = networkx.convert_node_labels_to_integers(G, discard_old_labels=False)
    try:
        posi = networkx.pygraphviz_layout(Gi, prog, args=args)
    except ImportError:
        try:
            posi = networkx.pydot_layout(Gi, prog)
        except ImportError:
            raise MissingPythonDependencyError(
                    "Install PyGraphviz or Pydot if you want to use "
                    "draw_graphviz.")
    posn = dict((n, posi[Gi.node_labels[n]]) for n in G)

    def get_label_mapping(G, selection):
        for node in G.nodes():
            if (selection is None) or (node in selection):
                try:
                    label = label_func(node)
                    if label not in (None, node.__class__.__name__):
                        yield (node, label)
                except (LookupError, AttributeError, ValueError):
                    pass

    if 'nodelist' in kwargs:
        labels = dict(get_label_mapping(G, set(kwargs['nodelist'])))
    else:
        labels = dict(get_label_mapping(G, None))
    kwargs['nodelist'] = labels.keys()
    if 'edge_color' not in kwargs:
        kwargs['edge_color'] = [isinstance(e[2], dict) and
                                e[2].get('color', 'k') or 'k'
                                for e in G.edges(data=True)]
    if 'width' not in kwargs:
        kwargs['width'] = [isinstance(e[2], dict) and
                           e[2].get('width', 1.0) or 1.0
                           for e in G.edges(data=True)]
    networkx.draw(G, posn, labels=labels, node_color=node_color, **kwargs)
Exemplo n.º 26
0
def doLayout(
    type
):  #type = (spring, circular, random, spectral, shell, pydot, graphviz)

    nodes = tc_itemsOfFamily("Biological entity")
    connections = tc_itemsOfFamily("Biological process")

    #connections are from 1...numConnections, nodes are the rest

    numNodes = nodes.length
    numConnections = connections.length

    M = []

    for i in range(0, numConnections):
        connected_nodes = tc_getConnectedNodes(tc_getItem(connections, i))
        for j in range(0, connected_nodes.length):
            n = 0
            for k in range(0, numNodes):
                if tc_getItem(nodes, k) == tc_getItem(connected_nodes, j):
                    n = k
                    break

            n += numConnections
            M.append((i, n))
            #connection i and node k are connected

    G = nx.Graph()
    G.add_nodes_from(range(0, numConnections + numNodes))
    G.add_edges_from(M)

    Pos = []
    if type == 'spring':
        Pos = nx.spring_layout(G)
    elif type == 'circular':
        Pos = nx.circular_layout(G)
    elif type == 'pydot':
        Pos = nx.pydot_layout(G)
    elif type == 'random':
        Pos = nx.random_layout(G)
    elif type == 'spectral':
        Pos = nx.spectral_layout(G)
    elif type == 'shell':
        Pos = nx.shell_layout(G)
    elif type == 'graphviz':
        Pos = nx.graphviz_layout(G)
    else:
        Pos = nx.spring_layout(G)
    minx = 0
    maxx = 0
    miny = 0
    maxy = 0
    for i in range(0, len(Pos)):
        if minx == 0 or minx > Pos[i][0]:
            minx = Pos[i][0]
        if miny == 0 or miny > Pos[i][1]:
            miny = Pos[i][1]
        if maxx == 0 or maxx < Pos[i][0]:
            maxx = Pos[i][0]
        if maxy == 0 or maxy < Pos[i][1]:
            maxy = Pos[i][0]

    width = (maxx - minx)
    height = (maxy - miny)

    for i in range(0, len(Pos)):
        Pos[i][0] *= 500.0 / width
        Pos[i][0] -= (500.0 * (minx) - 100.0)
        Pos[i][1] *= 500.0 / height
        Pos[i][1] -= (500.0 * (miny) - 100.0)

    Array = []
    PosX = []
    PosY = []

    for i in range(0, numConnections):
        Array.append(connections[i])
        PosX.append(Pos[i][0])
        PosY.append(Pos[i][1])

    for i in range(numConnections, numConnections + numNodes):
        Array.append(tc_getItem(nodes, i - numConnections))
        PosX.append(Pos[i][0])
        PosY.append(Pos[i][1])

    tc_setAllStraight(1)

    Array2 = tc_createItemsArray(len(Array))
    for i in range(0, len(Array)):
        tc_setItem(Array2, i, Array[i])

    Pos = tc_createMatrix(len(PosX), 2)
    for i in range(0, len(PosX)):
        tc_setMatrixValue(Pos, i, 0, PosX[i])
        tc_setMatrixValue(Pos, i, 1, PosY[i])

    tc_setPosMulti(Array2, Pos)

    print "layout finished"
Exemplo n.º 27
0
def draw_graphviz(tree, label_func=str, prog='twopi', args='',
        node_color='#c0deff', **kwargs):
    """Display a tree or clade as a graph, using the graphviz engine.

    Requires NetworkX, matplotlib, Graphviz and either PyGraphviz or pydot.

    Example:

        >>> import pylab
        >>> from Bio import Phylo
        >>> tree = Phylo.read('ex/apaf.xml', 'phyloxml')
        >>> Phylo.draw_graphviz(tree)
        >>> pylab.show()
        >>> pylab.savefig('apaf.png')

    The third and fourth parameters apply to Graphviz, and the remaining
    arbitrary keyword arguments are passed directly to networkx.draw(), which
    in turn mostly wraps matplotlib/pylab.  See the documentation for Graphviz
    and networkx for detailed explanations.

    The NetworkX/matplotlib parameters are described in the docstrings for
    networkx.draw() and pylab.scatter(), but the most reasonable options to try
    are: I{ alpha, node_color, node_size, node_shape, edge_color, style,
    font_size, font_color, font_weight, font_family }

    @param label_func: A function to extract a label from a node. By default
        this is str(), but you can use a different function to select another
        string associated with each node. If this function returns None for a
        node, no label will be shown for that node.

        The label will also be silently skipped if the throws an exception
        related to ordinary attribute access (LookupError, AttributeError,
        ValueError); all other exception types will still be raised. This
        means you can use a lambda expression that simply attempts to look up
        the desired value without checking if the intermediate attributes are
        available:

            >>> Phylo.draw_graphviz(tree, lambda n: n.taxonomies[0].code)

    @param prog: The Graphviz program to use when rendering the graph. 'twopi'
        behaves the best for large graphs, reliably avoiding crossing edges, but
        for moderate graphs 'neato' looks a bit nicer.  For small directed
        graphs, 'dot' may produce the most normal-looking phylogram, but will
        cross and distort edges in larger graphs. (The programs 'circo' and
        'fdp' are not recommended.)

    @param args: String of options passed to the external graphviz program.
        Normally not needed, but offered here for completeness.
    """
    try:
        import networkx
    except ImportError:
        from Bio import MissingPythonDependencyError
        raise MissingPythonDependencyError(
                "Install NetworkX if you want to use to_networkx.")

    G = to_networkx(tree)
    Gi = networkx.convert_node_labels_to_integers(G, discard_old_labels=False)
    try:
        posi = networkx.pygraphviz_layout(Gi, prog, args=args)
    except ImportError:
        try:
            posi = networkx.pydot_layout(Gi, prog)
        except ImportError:
            raise MissingPythonDependencyError(
                    "Install PyGraphviz or Pydot if you want to use "
                    "draw_graphviz.")
    posn = dict((n, posi[Gi.node_labels[n]]) for n in G)

    def get_label_mapping(G, selection):
        for node in G.nodes():
            if (selection is None) or (node in selection):
                try:
                    label = label_func(node)
                    if label not in (None, node.__class__.__name__):
                        yield (node, label)
                except (LookupError, AttributeError, ValueError):
                    pass

    if 'nodelist' in kwargs:
        labels = dict(get_label_mapping(G, set(kwargs['nodelist'])))
    else:
        labels = dict(get_label_mapping(G, None))
    kwargs['nodelist'] = labels.keys()
    if 'edge_color' not in kwargs:
        kwargs['edge_color'] = [isinstance(e[2], dict) and
                                e[2].get('color', 'k') or 'k'
                                for e in G.edges(data=True)]
    if 'width' not in kwargs:
        kwargs['width'] = [isinstance(e[2], dict) and
                           e[2].get('width', 1.0) or 1.0
                           for e in G.edges(data=True)]
    networkx.draw(G, posn, labels=labels, node_color=node_color, **kwargs)
Exemplo n.º 28
0
def bayesnet():
    """
    References:
        https://class.coursera.org/pgm-003/lecture/17
        http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
        http://www3.cs.stonybrook.edu/~sael/teaching/cse537/Slides/chapter14d_BP.pdf
        http://www.cse.unsw.edu.au/~cs9417ml/Bayes/Pages/PearlPropagation.html
        https://github.com/pgmpy/pgmpy.git
        http://pgmpy.readthedocs.org/en/latest/
        http://nipy.bic.berkeley.edu:5000/download/11
    """
    # import operator as op
    # # Enumerate all possible events
    # varcard_list = list(map(op.attrgetter('variable_card'), cpd_list))
    # _esdat = list(ut.iprod(*map(range, varcard_list)))
    # _escol = list(map(op.attrgetter('variable'), cpd_list))
    # event_space = pd.DataFrame(_esdat, columns=_escol)

    # # Custom compression of event space to inspect a specific graph
    # def compress_space_flags(event_space, var1, var2, var3, cmp12_):
    #     """
    #     var1, var2, cmp_ = 'Lj', 'Lk', op.eq
    #     """
    #     import vtool as vt
    #     data = event_space
    #     other_cols = ut.setdiff_ordered(data.columns.tolist(), [var1, var2, var3])
    #     case_flags12 = cmp12_(data[var1], data[var2]).values
    #     # case_flags23 = cmp23_(data[var2], data[var3]).values
    #     # case_flags = np.logical_and(case_flags12, case_flags23)
    #     case_flags = case_flags12
    #     case_flags = case_flags.astype(np.int64)
    #     subspace = np.hstack((case_flags[:, None], data[other_cols].values))
    #     sel_ = vt.unique_row_indexes(subspace)
    #     flags = np.logical_and(mask, case_flags)
    #     return flags

    # # Build special cases
    # case_same   = event_space.loc[compress_space_flags(event_space, 'Li', 'Lj', 'Lk', op.eq)]
    # case_diff = event_space.loc[compress_space_flags(event_space, 'Li', 'Lj', 'Lk', op.ne)]
    # special_cases = [
    #     case_same,
    #     case_diff,
    # ]

    from pgmpy.factors import TabularCPD
    from pgmpy.models import BayesianModel
    import pandas as pd
    from pgmpy.inference import BeliefPropagation  # NOQA
    from pgmpy.inference import VariableElimination  # NOQA

    name_nice = ['n1', 'n2', 'n3']
    score_nice = ['low', 'high']
    match_nice = ['diff', 'same']
    num_names = len(name_nice)
    num_scores = len(score_nice)
    nid_basis = list(range(num_names))
    score_basis = list(range(num_scores))

    semtype2_nice = {
        'score': score_nice,
        'name': name_nice,
        'match': match_nice,
    }
    var2_cpd = {
    }
    globals()['semtype2_nice'] = semtype2_nice
    globals()['var2_cpd'] = var2_cpd

    name_combo = np.array(list(ut.iprod(nid_basis, nid_basis)))
    combo_is_same = name_combo.T[0] == name_combo.T[1]
    def get_expected_scores_prob(level1, level2):
        part1 = combo_is_same * level1
        part2 = (1 - combo_is_same) * (1 - (level2))
        expected_scores_level = part1 + part2
        return expected_scores_level

    # def make_cpd():

    def name_cpd(aid):
        from pgmpy.factors import TabularCPD
        cpd = TabularCPD(
            variable='N' + aid,
            variable_card=num_names,
            values=[[1.0 / num_names] * num_names])
        cpd.semtype = 'name'
        return cpd

    name_cpds = [name_cpd('i'), name_cpd('j'), name_cpd('k')]
    var2_cpd.update(dict(zip([cpd.variable for cpd in name_cpds], name_cpds)))
    if True:
        num_same_diff = 2
        samediff_measure = np.array([
            # get_expected_scores_prob(.12, .2),
            # get_expected_scores_prob(.88, .8),
            get_expected_scores_prob(0, 0),
            get_expected_scores_prob(1, 1),
        ])
        samediff_vals = (samediff_measure / samediff_measure.sum(axis=0)).tolist()
        def samediff_cpd(aid1, aid2):
            cpd = TabularCPD(
                variable='A' + aid1 + aid2,
                variable_card=num_same_diff,
                values=samediff_vals,
                evidence=['N' + aid1, 'N' + aid2],  # [::-1],
                evidence_card=[num_names, num_names])  # [::-1])
            cpd.semtype = 'match'
            return cpd
        samediff_cpds = [samediff_cpd('i', 'j'), samediff_cpd('j', 'k'), samediff_cpd('k', 'i')]
        var2_cpd.update(dict(zip([cpd.variable for cpd in samediff_cpds], samediff_cpds)))

        if True:
            def score_cpd(aid1, aid2):
                semtype = 'score'
                evidence = ['A' + aid1 + aid2, 'N' + aid1, 'N' + aid2]
                evidence_cpds = [var2_cpd[key] for key in evidence]
                evidence_nice = [semtype2_nice[cpd.semtype] for cpd in evidence_cpds]
                evidence_card = list(map(len, evidence_nice))
                evidence_states = list(ut.iprod(*evidence_nice))
                variable_basis = semtype2_nice[semtype]

                variable_values = []
                for mystate in variable_basis:
                    row = []
                    for state in evidence_states:
                        if state[0] == state[1]:
                            if state[2] == 'same':
                                val = .2 if mystate == 'low' else .8
                            else:
                                val = 1
                                # val = .5 if mystate == 'low' else .5
                        elif state[0] != state[1]:
                            if state[2] == 'same':
                                val = .5 if mystate == 'low' else .5
                            else:
                                val = 1
                                # val = .9 if mystate == 'low' else .1
                        row.append(val)
                    variable_values.append(row)

                cpd = TabularCPD(
                    variable='S' + aid1 + aid2,
                    variable_card=len(variable_basis),
                    values=variable_values,
                    evidence=evidence,  # [::-1],
                    evidence_card=evidence_card)  # [::-1])
                cpd.semtype = semtype
                return cpd
        else:
            score_values = [
                [.8, .1],
                [.2, .9],
            ]
            def score_cpd(aid1, aid2):
                cpd = TabularCPD(
                    variable='S' + aid1 + aid2,
                    variable_card=num_scores,
                    values=score_values,
                    evidence=['A' + aid1 + aid2],  # [::-1],
                    evidence_card=[num_same_diff])  # [::-1])
                cpd.semtype = 'score'
                return cpd

        score_cpds = [score_cpd('i', 'j'), score_cpd('j', 'k')]
        cpd_list = name_cpds + score_cpds + samediff_cpds
    else:
        score_measure = np.array([get_expected_scores_prob(level1, level2)
                                  for level1, level2 in
                                  zip(np.linspace(.1, .9, num_scores),
                                      np.linspace(.2, .8, num_scores))])

        score_values = (score_measure / score_measure.sum(axis=0)).tolist()

        def score_cpd(aid1, aid2):
            cpd = TabularCPD(
                variable='S' + aid1 + aid2,
                variable_card=num_scores,
                values=score_values,
                evidence=['N' + aid1, 'N' + aid2],
                evidence_card=[num_names, num_names])
            cpd.semtype = 'score'
            return cpd
        score_cpds = [score_cpd('i', 'j'), score_cpd('j', 'k')]
        cpd_list = name_cpds + score_cpds
        pass

    input_graph = []
    for cpd in cpd_list:
        if cpd.evidence is not None:
            for evar in cpd.evidence:
                input_graph.append((evar, cpd.variable))
    name_model = BayesianModel(input_graph)
    name_model.add_cpds(*cpd_list)

    var2_cpd.update(dict(zip([cpd.variable for cpd in cpd_list], cpd_list)))
    globals()['var2_cpd'] = var2_cpd

    varnames = [cpd.variable for cpd in cpd_list]

    # --- PRINT CPDS ---

    cpd = score_cpds[0]
    def print_cpd(cpd):
        print('CPT: %r' % (cpd,))
        index = semtype2_nice[cpd.semtype]
        if cpd.evidence is None:
            columns = ['None']
        else:
            basis_lists = [semtype2_nice[var2_cpd[ename].semtype] for ename in cpd.evidence]
            columns = [','.join(x) for x in ut.iprod(*basis_lists)]
        data = cpd.get_cpd()
        print(pd.DataFrame(data, index=index, columns=columns))

    for cpd in name_model.get_cpds():
        print('----')
        print(cpd._str('phi'))
        print_cpd(cpd)

    # --- INFERENCE ---

    Ni = name_cpds[0]

    event_space_combos = {}
    event_space_combos[Ni.variable] = 0  # Set ni to always be Fred
    for cpd in cpd_list:
        if cpd.semtype == 'score':
            event_space_combos[cpd.variable] = list(range(cpd.variable_card))
    evidence_dict = ut.all_dict_combinations(event_space_combos)

    # Query about name of annotation k given different event space params

    def pretty_evidence(evidence):
        return [key + '=' + str(semtype2_nice[var2_cpd[key].semtype][val])
                for key, val in evidence.items()]

    def print_factor(factor):
        row_cards = factor.cardinality
        row_vars = factor.variables
        values = factor.values.reshape(np.prod(row_cards), 1).flatten()
        # col_cards = 1
        # col_vars = ['']
        basis_lists = list(zip(*list(ut.iprod(*[range(c) for c in row_cards]))))
        nice_basis_lists = []
        for varname, basis in zip(row_vars, basis_lists):
            cpd = var2_cpd[varname]
            _nice_basis = ut.take(semtype2_nice[cpd.semtype], basis)
            nice_basis = ['%s=%s' % (varname, val) for val in _nice_basis]
            nice_basis_lists.append(nice_basis)
        row_lbls = [', '.join(sorted(x)) for x in zip(*nice_basis_lists)]
        print(ut.repr3(dict(zip(row_lbls, values)), precision=3, align=True, key_order_metric='-val'))

    # name_belief = BeliefPropagation(name_model)
    name_belief = VariableElimination(name_model)
    import pgmpy
    import six  # NOQA

    def try_query(evidence):
        print('--------')
        query_vars = ut.setdiff_ordered(varnames, list(evidence.keys()))
        evidence_str = ', '.join(pretty_evidence(evidence))
        probs = name_belief.query(query_vars, evidence)
        factor_list = probs.values()
        joint_factor = pgmpy.factors.factor_product(*factor_list)
        print('P(' + ', '.join(query_vars) + ' | ' + evidence_str + ')')
        # print(six.text_type(joint_factor))
        factor = joint_factor  # NOQA
        # print_factor(factor)
        # import utool as ut
        print(ut.hz_str([(f._str(phi_or_p='phi')) for f in factor_list]))

    for evidence in evidence_dict:
        try_query(evidence)

    evidence = {'Aij': 1, 'Ajk': 1, 'Aki': 1, 'Ni': 0}
    try_query(evidence)

    evidence = {'Aij': 0, 'Ajk': 0, 'Aki': 0, 'Ni': 0}
    try_query(evidence)

    globals()['score_nice'] = score_nice
    globals()['name_nice'] = name_nice
    globals()['score_basis'] = score_basis
    globals()['nid_basis'] = nid_basis

    print('Independencies')
    print(name_model.get_independencies())
    print(name_model.local_independencies([Ni.variable]))

    # name_belief = BeliefPropagation(name_model)
    # # name_belief = VariableElimination(name_model)
    # for case in special_cases:
    #     test_data = case.drop('Lk', axis=1)
    #     test_data = test_data.reset_index(drop=True)
    #     print('----')
    #     for i in range(test_data.shape[0]):
    #         evidence = test_data.loc[i].to_dict()
    #         probs = name_belief.query(['Lk'], evidence)
    #         factor = probs['Lk']
    #         probs = factor.values
    #         evidence_ = evidence.copy()
    #         evidence_['Li'] = name_nice[evidence['Li']]
    #         evidence_['Lj'] = name_nice[evidence['Lj']]
    #         evidence_['Sij'] = score_nice[evidence['Sij']]
    #         evidence_['Sjk'] = score_nice[evidence['Sjk']]
    #         nice2_prob = ut.odict(zip(name_nice, probs.tolist()))
    #         ut.print_python_code('P(Lk | {evidence}) = {cpt}'.format(
    #             evidence=(ut.repr2(evidence_, explicit=True, nobraces=True, strvals=True)),
    #             cpt=ut.repr3(nice2_prob, precision=3, align=True, key_order_metric='-val')
    #         ))

    # for case in special_cases:
    #     test_data = case.drop('Lk', axis=1)
    #     test_data = test_data.drop('Lj', axis=1)
    #     test_data = test_data.reset_index(drop=True)
    #     print('----')
    #     for i in range(test_data.shape[0]):
    #         evidence = test_data.loc[i].to_dict()
    #         query_vars = ['Lk', 'Lj']
    #         probs = name_belief.query(query_vars, evidence)
    #         for queryvar in query_vars:
    #             factor = probs[queryvar]
    #             print(factor._str('phi'))
    #             probs = factor.values
    #             evidence_ = evidence.copy()
    #             evidence_['Li'] = name_nice[evidence['Li']]
    #             evidence_['Sij'] = score_nice[evidence['Sij']]
    #             evidence_['Sjk'] = score_nice[evidence['Sjk']]
    #             nice2_prob = ut.odict(zip([queryvar + '=' + x for x in name_nice], probs.tolist()))
    #             ut.print_python_code('P({queryvar} | {evidence}) = {cpt}'.format(
    #                 query_var=query_var,
    #                 evidence=(ut.repr2(evidence_, explicit=True, nobraces=True, strvals=True)),
    #                 cpt=ut.repr3(nice2_prob, precision=3, align=True, key_order_metric='-val')
    #             ))

    # _ draw model

    import plottool as pt
    import networkx as netx
    fig = pt.figure()  # NOQA
    fig.clf()
    ax = pt.gca()

    netx_nodes = [(node, {}) for node in name_model.nodes()]
    netx_edges = [(etup[0], etup[1], {}) for etup in name_model.edges()]
    netx_graph = netx.DiGraph()
    netx_graph.add_nodes_from(netx_nodes)
    netx_graph.add_edges_from(netx_edges)

    # pos = netx.graphviz_layout(netx_graph)
    pos = netx.pydot_layout(netx_graph, prog='dot')
    netx.draw(netx_graph, pos=pos, ax=ax, with_labels=True)

    pt.plt.savefig('foo.png')
    ut.startfile('foo.png')