Class LGBayesianNetwork

libpgm/lgbayesiannetwork.py:44–177

This class represents a Bayesian network with linear Gaussian CPDs. It contains the attributes *V*, *E*, and *Vdata*, as well as the method *randomsample*.

from orderedskeleton import OrderedSkeleton

class LGBayesianNetwork(OrderedSkeleton):
    '''
    This class represents a Bayesian network with linear Gaussian CPDs. It contains the attributes *V*, *E*, and *Vdata*, as well as the method *randomsample*. 
   
    '''

    def __init__(self, orderedskeleton=None, nodedata=None):
        '''
        This class can be called either with or without arguments. If it is called without arguments, none of its attributes are instantiated and it is left to the user to instantiate them manually. If it is called with arguments, the attributes will be loaded directly from the inputs. The arguments must be (in order):

            1. *orderedskeleton* -- An instance of the :doc:`OrderedSkeleton <orderedskeleton>` or :doc:`GraphSkeleton <graphskeleton>` (as long as it&#x27;s ordered) class.
            2. *nodedata* -- An instance of the :doc:`NodeData <nodedata>` class.

        If these arguments are present, all attributes of the class (*V*, *E*, and *Vdata*) will be automatically copied from the graph skeleton and node data inputs.
        
        This class requires that the *Vdata* attribute gets loaded with a dictionary with node data of the following fomat::

            "vertex": {
                "parents": ["<name of parent 1>", ... , "<name of parent n>"],
                "children": ["<name of child 1>", ... , "<name of child n>"],   
                "mean_base": <the base mean of the Gaussian distribution>,
                "mean_scal": [<scalar for parent 1 outcome>, ... , <scalar for parent n outcome>],
                "variance": <variance of the Gaussian distibution>
            }

        Note that additional keys are possible in the dict of each vertex.

        Upon loading, the class will also check that the keys of *Vdata* correspond to the vertices in *V*.

        ''&#x27;
        if (orderedskeleton != None and nodedata != None):
            try:
                self.V = orderedskeleton.V
                '''A list of the names of the vertices.'''
                self.E = orderedskeleton.E
                '''A list of [origin, destination] pairs of vertices that make edges.'''
                self.Vdata = nodedata.Vdata
                '''A dictionary containing CPD data for the nodes.'''
            except: 
                raise Exception, "Inputs were malformed; first arg must contain V and E attributes and second arg must contain Vdata attribute."

            assert sorted(self.V) == sorted(self.Vdata.keys()), "Vertices did not match node data"

    def randomsample(self, n, evidence=None, mode="normal"):
        ''&#x27;
        Produce *n* random samples from the Bayesian Network and return them in a list. 
       
        See above for how the means of linear Gaussians are calculated during sampling.

        This function takes the following arguments:

            1. *n* -- The number of random samples to produce.
            2. *evidence* -- (Optional) A dict containing (vertex: value) pairs that describe the evidence. To be used carefully because it does manually overrides the nodes with evidence instead of affecting the joint probability distribution of the entire graph.
            3. *mode* -- (Optional) Can be set to "verbose", whereupon the method will return a [value, mean, variance] list for each node rather than just the actual value.  
        
        And returns:
            A list of *n* independent random samples, each element of which is a dict containing (vertex: value) pairs.