pynet.py

The library is a C++/Python implementation of the variational building block framework introduced in

        com = re.compile(regexp)
        for i in range(self.NodeCount()):
            node = self.GetNodeByIndex(i)
            if com.match(node.GetLabel()):
                res.append(node)
        return res

    def GetNodeArray(self, regexp, getter="GetNodes"):
        nodes = getattr(self, getter)(regexp)
        labels = map(lambda n: Unlabel(n.GetLabel()), nodes)
        maxinds = {}
        for l in labels:
            if not maxinds.has_key(l[0]):
                maxinds[l[0]] = list(l[1])
            else:
                maxinds[l[0]] = map(max, maxinds[l[0]], list(l[1]))
        if len(maxinds.keys()) > 1:
            raise ValueError("Regexp matches to more than one matrix")
        inds = map(lambda x: x+1, maxinds[maxinds.keys()[0]])
        arraysize = reduce(lambda x, y: x*y, inds, 1)
        val = Numeric.reshape(Numeric.array(
            [None]*arraysize, Numeric.PyObject), inds)
        for k in range(len(nodes)):
            val[labels[k][1]] = nodes[k]
        return val

    def GetVariableArray(self, regexp):
        return self.GetNodeArray(regexp, getter="GetVariables")

    def ShowVariables(self, regexp = '', showtype = 0):
        if showtype == 0:
            scafunc = Helpers.GetMean
            vecfunc = Helpers.GetMeanV
        elif showtype == 1:
            scafunc = Helpers.GetVar
            vecfunc = Helpers.GetVarV
        else:
            scafunc = Helpers.GetExp
            vecfunc = Helpers.GetExpV
        nodes = self.GetVariables(regexp)
        for node in nodes:
            print node.GetLabel(),
            if node.GetType()[-1] == 'V':
                print min(Numeric.array(vecfunc(node))),
                print max(Numeric.array(vecfunc(node)))
            else:
                print scafunc(node)

    def ShowNodes(self, regexp = '', showtype = 0):
        if showtype == 0:
            scafunc = Helpers.GetMean
            vecfunc = Helpers.GetMeanV
        elif showtype == 1:
            scafunc = Helpers.GetVar
            vecfunc = Helpers.GetVarV
        else:
            scafunc = Helpers.GetExp
            vecfunc = Helpers.GetExpV
        nodes = self.GetNodes(regexp)
        for node in nodes:
            print node.GetLabel(),
            if node.GetType()[-1] == 'V':
                print min(Numeric.array(vecfunc(node))),
                print max(Numeric.array(vecfunc(node)))
            else:
                print scafunc(node)


    def MakeNodes(self, nodetype, labelbase, num, *parents):
        warnings.warn("method deprecated", DeprecationWarning, stacklevel=2)

        c = []
        if type(labelbase) != type(()):
            tmp = Unlabel(labelbase)
            labelbase = (tmp[0],) + tmp[1]
        if type([]) not in map(type, parents):
            for i in range(num):
                c.append(apply(nodetype,
                               (self, apply(Label, labelbase + (i, ))) +
                               parents))
        else:
            if len(parents) > 1:
                parents=list(parents)
                for j in range(len(parents)):
                    if type(parents[j]) is not type([]):
                        parents[j] = [parents[j]]*num
                pars = map(tuple, list(Numeric.transpose(Numeric.array(parents))))
            else:
                pars = map(lambda x: (x, ), parents[0])
            for i in range(num):
                c.append(apply(nodetype,
                               (self, apply(Label, labelbase + (i, ))) +
                               pars[i]))
        return c
    
    def MakeGaussians(self, labelbase, mpar, vpar, num):
        """Deprecated, use MakeNodes instead"""
        return self.MakeNodes(Gaussian, labelbase, num, mpar, vpar)

    def MakeGaussianVs(self, labelbase, mpar, vpar, num):
        """Deprecated, use MakeNodes instead"""
        return self.MakeNodes(GaussianV, labelbase, num, mpar, vpar)

    def SortByNet(self,nodes):
        """ Returns nodes sorted in topological order. First calls net to
        sort itself topologically and then sorts the nodes in same order
        as they are returned by net.GetNodeByIndex(i).
        """
        self.SortNodes()
        nodedict = {}
        sorted = []
        for i in nodes:
            nodedict[i.GetLabel()] = 1
        for i in range(self.NodeCount()):
            l = self.GetNodeByIndex(i).GetLabel()
            if nodedict.has_key(l):
                nodedict[l] = 0
                sorted.append(self.GetNode(l))
        assert(len(nodes)==len(sorted))
        return sorted

    def GetVectorNodes(self):
        res = []
        self.SortNodes()
        for i in range(self.NodeCount()):
            node = self.GetNodeByIndex(i)
            if node.GetType()[-1] == 'V' and node.GetType() != 'ConstantV':
                res.append(node)
        return res
            
    def GenerateTestNodes(self, vectors=1, typemap = {}):
        warnings.warn("method deprecated", DeprecationWarning, stacklevel=2)
        nodes=self.GetVectorNodes()
        node_map = {}

        for v in nodes:
            if v.GetType() in ("ConstantV",):
                if vectors == 0:
                    raise RuntimeError, "If vectors is false ConstantV:s can't be copyed"
                else:
                    node_map[v.GetLabel()] = v
            elif v.GetType() in ("SwitchV", "DelayV", "DelayGaussV",
                               "EvidenceV","TestProdV","DiscreteV"):
                raise RuntimeError, "Copying of " + v.GetType() +\
                      " nodes is not implemented."
            elif v.GetType() in ("ProdV", "Sum2V", "GaussianV",
                               "SparseGaussV", "GaussNonlinV"):
                par = []
                i = 0
                while v.GetParent(i) is not None:
                    par.append(node_map.get(v.GetParent(i).GetLabel(),
                                            v.GetParent(i)))
                    assert(not (par[i].GetType()[-1] == 'V' and
                                par[i].GetLabel()[0:5] != "Copy_"))
                    i += 1
            else:
                raise RuntimeError, "Unknown vector node type: " + v.GetType()
            if vectors:
                copy = apply(typemap.get(v.GetLabel(), eval(v.GetType())),
                             (self, "Copy_" + v.GetLabel()) + tuple(par))
            else:
                type = v.GetType()[:-1]
                if type == "SparseGauss":
                    type = "Gaussian"
                copy = apply(typemap.get(v.GetLabel(), eval(type)),
                             (self, "Copy_" + v.GetLabel()) + tuple(par))
            node_map[v.GetLabel()] = copy
        return node_map

    def EvidenceNode(self, node, label=None, mean=0, var=0.01,
                     decay=4.0, hook="UpdateAll"):
        warnings.warn("method deprecated", DeprecationWarning, stacklevel=2)

        if label is None:
            label =  "evidence_" + node.GetLabel()
        tmp = Evidence(self, label, node)
        tmp.Clamp(mean, var)
        tmp.SetDecayTime(decay)
        self.RegisterDecay(tmp, hook)
        node.Update()

    def EvidenceVNode(self, node, label=None, mean=0, var=0.01,
                     decay=4.0, hook="UpdateAll"):
        warnings.warn("method deprecated", DeprecationWarning, stacklevel=2)

        if label is None:
            label =  "evidence_" + node.GetLabel()
        tmp = EvidenceV(self, label, node)
	time = self.Time()
	if not _issequence(mean):
	    mean = [mean] * time
	if not _issequence(var):
	    var = [var] * time
        tmp.Clamp(mean, var)
	if not _issequence(decay):
	    decay = [decay] * time
        tmp.SetDecayTime(decay)
        self.RegisterDecay(tmp, hook)
        node.Update()

    def GetGaussianNode(self, name, recursion=0, noevidence=0):
        if recursion > 5:
            print name
            raise RuntimeError, "maximum recursion depth for GetGaussianNode exceeded"
        node = self.GetNode(name)
        if node is None:
            if self.priorlist.has_key(name):
                (mlabel, vlabel) = self.priorlist[name]
            else:
                tmp = Unlabel(name);
                label = Label(tmp[0], tmp[1][:-1])
                mlabel = 'm' + label
                vlabel = 'v' + label
            m = self.GetGaussianNode(mlabel,recursion=recursion+1)
            v = self.GetGaussianNode(vlabel,recursion=recursion+1)
            if m is None or v is None:
                raise RuntimeError,"Parents not found in " + \
                      "GetNode() " + mlabel + " " + vlabel
            node = Gaussian(self, name, m, v)
            node.SetPersist(5)
            if not noevidence:
                self.EvidenceNode(node, mean=0, var=1, decay=1)
        return node

    def GetCostDict(self):
        d = {}
        for i in range(self.VariableCount()):
            n = self.GetVariableByIndex(i)
            d[n.GetLabel()] = n.Cost()
        return d

    def CheckStructureP(self):
        self.SortNodes()
        variables = self.GetVariables('')
        delays = filter(lambda x: x.GetType() == 'DelayV',
                        self.GetNodes(''))
        vardelay = {}
        for x in variables + delays:
            vardelay[x.GetLabel()] = None
        for v in variables + delays:
            check = [v]
            checkednodes = {v.GetLabel():None}
            while len(check):
                node = check.pop()
                for c in Helpers.ChildList(node):
                    l = c.GetLabel()
                    if checkednodes.has_key(l):
                        raise ValueError, \
                              "Invalid structure of the network." +\
                              " More than one route from " + v.GetLabel() +\
                              " to " + l + "."
                        return 1
                    checkednodes[l]=None
                    if not vardelay.has_key(l):
                        check.append(c)
        return


class PyNodeFactory(NodeFactory):
    """All node creation utilities should be moved here."""

    def __getstate__(self):
        return {'pynet': self.pynet}

    def __setstate__(self, dict):
        self.__init__(dict['pynet'])

    def __init__(self, net):
        # some type safety enforced
        if not isinstance(net, PyNet):
            raise ValueError, "Net is not an instance of PyNet"
        NodeFactory.__init__(self, net)
        self.pynet = net

    def GetPyNet(self):
        return self.pynet

    def __repr__(self):
        msg = "<PyNodeFactory instance wrapping C NodeFactory instance"
        msg += "at %s>" % (self.this,)
        return msg

    def MakeNode(self, nodetype, label, parents):
        """Creates a node of type nodetype with given parents."""
        factmethod = getattr(self, "Get" + nodetype)
        return apply(factmethod, (label,) + parents)

    def MakeNodes(self, nodetype, labelbase, num, *parents):
        """Creates num instances of nodetype (which is the string returned
        by GetType i.e. the classname)."""
        if type(labelbase) == type(()):
            stem = labelbase[0]
            indices = labelbase[1:]
        else:
            stem, indices = Unlabel(labelbase)

        if len(parents) > 0:
            par = []

            for i in range(len(parents)):
                if type(parents[i]) == type([]):
                    assert len(parents[i]) == num
                    par.append(parents[i])
                else:
                    par.append([parents[i]] * num)

            rap = apply(zip, par)
        else:
            rap = [()] * num

        return [self.MakeNode(nodetype, Label(stem, indices + (i,)), rap[i])
                for i in range(num)]

    def EvidenceNode(self, node, label=None, mean=0, var=0.01,
                     decay=4.0, hook="UpdateAll"):
        if label is None:
            label = "evidence_" + node.GetLabel()
        tmp = self.GetEvidence(label, node)
        tmp.Clamp(mean, var)
        tmp.SetDecayTime(decay)
        self.GetPyNet().RegisterDecay(tmp, hook)
        node.Update()

    def EvidenceVNode(self, node, label=None, mean=0, var=0.01,
                     decay=4.0, hook="UpdateAll"):
        if label is None:
            label =  "evidence_" + node.GetLabel()
        tmp = self.GetEvidenceV(label, node)
	time = self.GetPyNet().Time()
	if not _issequence(mean):
	    mean = [mean] * time
	if not _issequence(var):
	    var = [var] * time
        tmp.Clamp(mean, var)
	if not _issequence(decay):
	    decay = [decay] * time
        tmp.SetDecayTime(decay)
        self.GetPyNet().RegisterDecay(tmp, hook)
        node.Update()

    def BuildBalancedTree(self, nodetype, nodes, labelbase):
        nodes = nodes[:]

        if len(nodes) == 1:
            return nodes[0]
        j = 0
        if type(labelbase) in (type(()), type([])):
            leaflabel = list(labelbase)
        else:
            leaflabel = [labelbase]
            labelbase = (labelbase, )
        leaflabel[0] += "_leaf"
        leaflabel = tuple(leaflabel)
        while len(nodes) > 2:
            tmp = self.MakeNode(nodetype, apply(Label, leaflabel + (j, )),
                                (nodes.pop(0), nodes.pop(0)))
            j += 1
            nodes.append(tmp)
        return self.MakeNode(nodetype, apply(Label, labelbase),
                             (nodes.pop(0), nodes.pop(0)))

    def BuildSum2VTree(self, nodes, labelbase):
        return self.BuildBalancedTree("Sum2V", nodes, labelbase)

    def BuildSum2Tree(self, nodes, labelbase):
        return self.BuildBalancedTree("Sum2", nodes, labelbase)

    def GetConst0(self):
        const0 = self.GetPyNet().GetNode('const0')
        if const0 is None:
            const0 = self.GetConstant('const0', 0.0)
        return const0

    def GenerateTestNodes(self, vectors=1, typemap = {}):
        nodes=self.pynet.GetVectorNodes()
        node_map = {}

        for v in nodes:
            if v.GetType() in ("ConstantV",):
                if vectors == 0:
                    raise RuntimeError, "If vectors is false ConstantV:s can't be copyed"
                else:
                    node_map[v.GetLabel()] = v
            elif v.GetType() in ("SwitchV", "DelayV", "DelayGaussV",
                               "EvidenceV","TestProdV","DiscreteV"):
                raise RuntimeError, "Copying of " + v.GetType() +\
                      " nodes is not implemented."
            elif v.GetType() in ("ProdV", "Sum2V", "GaussianV",
                               "SparseGaussV", "GaussNonlinV"):
                par = []
                i = 0
                while v.GetParent(i) is not None:
                    par.append(node_map.get(v.GetParent(i).GetLabel(),
                                            v.GetParent(i)))
                    assert(not (par[i].GetType()[-1] == 'V' and
                                par[i].GetLabel()[0:5] != "Copy_"))
                    i += 1
            else:
                raise RuntimeError, "Unknown vector node type: " + v.GetType()
            if vectors:
                copy = self.MakeNode(typemap.get(v.GetLabel(), v.GetType()),
                                     "Copy_" + v.GetLabel(), tuple(par))
            else:
                type = v.GetType()[:-1]
                if type == "SparseGauss":
                    type = "Gaussian"
                copy = self.MakeNode(typemap.get(v.GetLabel(), type),
                                     "Copy_" + v.GetLabel() + tuple(par))
            node_map[v.GetLabel()] = copy
        return node_map