PR comments

5 files changed, 186 insertions, 189 deletions

diff --git a/beliefs/models/DirectedGraph.py b/beliefs/models/DirectedGraph.py
deleted file mode 100644
index 84b3a02..0000000
--- a/beliefs/models/DirectedGraph.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import networkx as nx
-
-
-class DirectedGraph(nx.DiGraph):
-    """
-    Base class for all directed graphical models.
-    """
-    def __init__(self, edges=None, node_labels=None):
-        """
-        Input:
-            edges: an edge list, e.g. [(parent1, child1), (parent1, child2)]
-            node_labels: a list of strings of node labels
-        """
-        super().__init__()
-        if edges is not None:
-            self.add_edges_from(edges)
-        if node_labels is not None:
-            self.add_nodes_from(node_labels)
-
-    def get_leaves(self):
-        """
-        Returns a list of leaves of the graph.
-        """
-        return [node for node, out_degree in self.out_degree() if out_degree == 0]
-
-    def get_roots(self):
-        """
-        Returns a list of roots of the graph.
-        """
-        return [node for node, in_degree in self.in_degree() if in_degree == 0]
-
-    def get_topologically_sorted_nodes(self, reverse=False):
-        if reverse:
-            return list(reversed(list(nx.topological_sort(self))))
-        else:
-            return nx.topological_sort(self)
diff --git a/beliefs/models/BayesianModel.py b/beliefs/models/base_models.py
index b57f968..cb91566 100644
--- a/beliefs/models/BayesianModel.py
+++ b/beliefs/models/base_models.py
@@ -1,10 +1,43 @@
-import copy
 import networkx as nx
 
-from beliefs.models.DirectedGraph import DirectedGraph
 from beliefs.utils.math_helper import is_kronecker_delta
 
 
+class DirectedGraph(nx.DiGraph):
+    """
+    Base class for all directed graphical models.
+    """
+    def __init__(self, edges=None, node_labels=None):
+        """
+        Input:
+            edges: an edge list, e.g. [(parent1, child1), (parent1, child2)]
+            node_labels: a list of strings of node labels
+        """
+        super().__init__()
+        if edges is not None:
+            self.add_edges_from(edges)
+        if node_labels is not None:
+            self.add_nodes_from(node_labels)
+
+    def get_leaves(self):
+        """
+        Returns a list of leaves of the graph.
+        """
+        return [node for node, out_degree in self.out_degree() if out_degree == 0]
+
+    def get_roots(self):
+        """
+        Returns a list of roots of the graph.
+        """
+        return [node for node, in_degree in self.in_degree() if in_degree == 0]
+
+    def get_topologically_sorted_nodes(self, reverse=False):
+        if reverse:
+            return list(reversed(list(nx.topological_sort(self))))
+        else:
+            return nx.topological_sort(self)
+
+
 class BayesianModel(DirectedGraph):
     """
     Bayesian model stores nodes and edges described by conditional probability
@@ -69,8 +102,8 @@ class BayesianModel(DirectedGraph):
         return vars_in_definite_state - observed
 
     def _get_ancestors_of(self, observed):
-        """Return list of ancestors of observed labels, including the observed labels themselves."""
-        ancestors = observed.copy()
+        """Return list of ancestors of observed labels"""
+        ancestors = set()
         for label in observed:
             ancestors.update(nx.ancestors(self, label))
         return ancestors
@@ -87,7 +120,9 @@ class BayesianModel(DirectedGraph):
           reachable_observed_vars: set of strings, observed labels (variables with direct
               evidence) that are reachable from the source label.
         """
+        # ancestors of observed labels, including observed labels
         ancestors_of_observed = self._get_ancestors_of(observed)
+        ancestors_of_observed.update(observed)
 
         visit_list = set()
         visit_list.add((source, 'up'))
diff --git a/beliefs/models/beliefupdate/Node.py b/beliefs/models/belief_update_node_model.py
index daa2f14..667e0f1 100644
--- a/beliefs/models/beliefupdate/Node.py
+++ b/beliefs/models/belief_update_node_model.py
@@ -1,6 +1,13 @@
+import copy
+from enum import Enum
 import numpy as np
+import itertools
 from functools import reduce
-from enum import Enum
+
+import networkx as nx
+
+from beliefs.models.base_models import BayesianModel
+from beliefs.factors.bernoulli_or_cpd import BernoulliOrCPD
 
 
 class InvalidLambdaMsgToParent(Exception):
@@ -13,6 +20,98 @@ class MessageType(Enum):
     PI = 'pi'
 
 
+class BeliefUpdateNodeModel(BayesianModel):
+    """
+    A Bayesian model storing nodes (e.g. Node or BernoulliOrNode) implementing properties
+    and methods for Pearl's belief update algorithm.
+
+    ref: "Fusion, Propagation, and Structuring in Belief Networks"
+          Artificial Intelligence 29 (1986) 241-288
+
+    """
+    def __init__(self, nodes_dict):
+        """
+        Input:
+          nodes_dict: dict
+            a dict key, value pair as {label_id: instance_of_node_class_or_subclass}
+        """
+        super().__init__(edges=self._get_edges_from_nodes(nodes_dict.values()),
+                         variables=list(nodes_dict.keys()),
+                         cpds=[node.cpd for node in nodes_dict.values()])
+
+        self.nodes_dict = nodes_dict
+
+    @classmethod
+    def init_from_edges(cls, edges, node_class):
+        """Create nodes from the same node class.
+
+        Input:
+           edges: list of edge tuples of form ('parent', 'child')
+           node_class: the Node class or subclass from which to
+                 create all the nodes from edges.
+        """
+        nodes = set()
+        g = nx.DiGraph(edges)
+
+        for label in set(itertools.chain(*edges)):
+            node = node_class(label_id=label,
+                              children=list(g.successors(label)),
+                              parents=list(g.predecessors(label)))
+            nodes.add(node)
+        nodes_dict = {node.label_id: node for node in nodes}
+        return cls(nodes_dict)
+
+    @staticmethod
+    def _get_edges_from_nodes(nodes):
+        """
+        Return list of all directed edges in nodes.
+
+        Args:
+            nodes: an iterable of objects of the Node class or subclass
+        Returns:
+            edges: list of edge tuples
+        """
+        edges = set()
+        for node in nodes:
+            if node.parents:
+                edge_tuples = zip(node.parents, [node.label_id]*len(node.parents))
+                edges.update(edge_tuples)
+        return list(edges)
+
+    def set_boundary_conditions(self):
+        """
+        1. Root nodes: if x is a node with no parents, set Pi(x) = prior
+        probability of x.
+
+        2. Leaf nodes: if x is a node with no children, set Lambda(x)
+        to an (unnormalized) unit vector, of length the cardinality of x.
+        """
+        for root in self.get_roots():
+            self.nodes_dict[root].pi_agg = self.nodes_dict[root].cpd.values
+
+        for leaf in self.get_leaves():
+            self.nodes_dict[leaf].lambda_agg = np.ones([self.nodes_dict[leaf].cardinality])
+
+    @property
+    def all_nodes_are_fully_initialized(self):
+        """
+        Returns True if, for all nodes in the model, all lambda and pi
+        messages and lambda_agg and pi_agg are not None, else False.
+        """
+        for node in self.nodes_dict.values():
+            if not node.is_fully_initialized:
+                return False
+        return True
+
+    def copy(self):
+        """
+        Returns a copy of the model.
+        """
+        copy_nodes = copy.deepcopy(self.nodes_dict)
+        copy_model = self.__class__(nodes_dict=copy_nodes)
+        return copy_model
+
+
 class Node:
     """A node in a DAG with methods to compute the belief (marginal probability
     of the node given evidence) and compute pi/lambda messages to/from its neighbors
@@ -102,8 +201,8 @@ class Node:
 
         if any(msg is None for msg in msg_values):
             raise ValueError(
-                "Missing value for {msg_type} msg from child: can't compute {msg_type}_agg.".
-                format(msg_type=message_type.value)
+                "Missing value for {msg_type} msg from child: can't compute {msg_type}_agg."
+                .format(msg_type=message_type.value)
             )
         else:
             return msg_values
@@ -122,16 +221,16 @@ class Node:
 
     def _update_received_msg_by_key(self, received_msg_dict, key, new_value):
         if key not in received_msg_dict.keys():
-            raise ValueError("Label id '{}' to update message isn't in allowed set of keys: {}".
-                             format(key, received_msg_dict.keys()))
+            raise ValueError("Label id '{}' to update message isn't in allowed set of keys: {}"
+                             .format(key, received_msg_dict.keys()))
 
         if not isinstance(new_value, np.ndarray):
-            raise TypeError("Expected a new value of type numpy.ndarray, but got type {}".
-                            format(type(new_value)))
+            raise TypeError("Expected a new value of type numpy.ndarray, but got type {}"
+                            .format(type(new_value)))
 
         if new_value.shape != (self.cardinality,):
-            raise ValueError("Expected new value to be of dimensions ({},) but got {} instead".
-                             format(self.cardinality, new_value.shape))
+            raise ValueError("Expected new value to be of dimensions ({},) but got {} instead"
+                             .format(self.cardinality, new_value.shape))
         received_msg_dict[key] = new_value
 
     def update_pi_msg_from_parent(self, parent, new_value):
@@ -152,8 +251,7 @@ class Node:
                 return self._normalize(
                     np.nan_to_num(np.divide(self.belief, lambda_msg_from_child)))
         else:
-            raise ValueError("Can't compute pi message to child_{} without having received" \
-                             "a lambda message from that child.")
+            raise ValueError("Can't compute pi message to child_{} without having received a lambda message from that child.")
 
     def compute_lambda_msg_to_parent(self, parent_k):
         # TODO: implement explict factor product operation
@@ -177,3 +275,41 @@ class Node:
             return False
 
         return True
+
+
+class BernoulliOrNode(Node):
+    def __init__(self,
+                 label_id,
+                 children,
+                 parents):
+        super().__init__(label_id=label_id,
+                         children=children,
+                         parents=parents,
+                         cardinality=2,
+                         cpd=BernoulliOrCPD(label_id, parents))
+
+    def compute_pi_agg(self):
+        if not self.parents:
+            self.pi_agg = self.cpd.values
+        else:
+            pi_msg_values = self.validate_and_return_msgs_received_for_msg_type(MessageType.PI)
+            parents_p0 = [p[0] for p in pi_msg_values]
+            p_0 = reduce(lambda x, y: x*y, parents_p0)
+            p_1 = 1 - p_0
+            self.pi_agg = np.array([p_0, p_1])
+        return self.pi_agg
+
+    def compute_lambda_msg_to_parent(self, parent_k):
+        if np.array_equal(self.lambda_agg, np.ones([self.cardinality])):
+            return np.ones([self.cardinality])
+        else:
+            # TODO: cleanup this validation
+            _ = self.validate_and_return_msgs_received_for_msg_type(MessageType.PI)
+            p0_excluding_k = [msg[0] for par_id, msg in self.pi_received_msgs.items() if par_id != parent_k]
+            p0_product = reduce(lambda x, y: x*y, p0_excluding_k, 1)
+            lambda_0 = self.lambda_agg[1] + (self.lambda_agg[0] - self.lambda_agg[1])*p0_product
+            lambda_1 = self.lambda_agg[1]
+            lambda_msg = np.array([lambda_0, lambda_1])
+            if not any(lambda_msg):
+                raise InvalidLambdaMsgToParent
+            return self._normalize(lambda_msg)
diff --git a/beliefs/models/beliefupdate/BeliefUpdateNodeModel.py b/beliefs/models/beliefupdate/BeliefUpdateNodeModel.py
deleted file mode 100644
index d74eaa7..0000000
--- a/beliefs/models/beliefupdate/BeliefUpdateNodeModel.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import copy
-import numpy as np
-
-from beliefs.models.BayesianModel import BayesianModel
-from beliefs.utils.edges_helper import EdgesHelper
-
-
-class BeliefUpdateNodeModel(BayesianModel):
-    """
-    A Bayesian model storing nodes (e.g. Node or BernoulliOrNode) implementing properties
-    and methods for Pearl's belief update algorithm.
-
-    ref: "Fusion, Propagation, and Structuring in Belief Networks"
-          Artificial Intelligence 29 (1986) 241-288
-
-    """
-    def __init__(self, nodes_dict):
-        """
-        Input:
-          nodes_dict: dict
-            a dict key, value pair as {label_id: instance_of_node_class_or_subclass}
-        """
-        super().__init__(edges=self._get_edges_from_nodes(nodes_dict.values()),
-                         variables=list(nodes_dict.keys()),
-                         cpds=[node.cpd for node in nodes_dict.values()])
-
-        self.nodes_dict = nodes_dict
-
-    @classmethod
-    def from_edges(cls, edges, node_class):
-        """Create nodes from the same node class.
-
-        Input:
-           edges: list of edge tuples of form ('parent', 'child')
-           node_class: the Node class or subclass from which to
-                 create all the nodes from edges.
-        """
-        edges_helper = EdgesHelper(edges)
-        nodes = edges_helper.create_nodes_from_edges(node_class)
-        nodes_dict = {node.label_id: node for node in nodes}
-        return cls(nodes_dict)
-
-    @staticmethod
-    def _get_edges_from_nodes(nodes):
-        """
-        Return list of all directed edges in nodes.
-
-        Args:
-            nodes: an iterable of objects of the Node class or subclass
-        Returns:
-            edges: list of edge tuples
-        """
-        edges = set()
-        for node in nodes:
-            if node.parents:
-                edge_tuples = zip(node.parents, [node.label_id]*len(node.parents))
-                edges.update(edge_tuples)
-        return list(edges)
-
-    def set_boundary_conditions(self):
-        """
-        1. Root nodes: if x is a node with no parents, set Pi(x) = prior
-        probability of x.
-
-        2. Leaf nodes: if x is a node with no children, set Lambda(x)
-        to an (unnormalized) unit vector, of length the cardinality of x.
-        """
-        for root in self.get_roots():
-            self.nodes_dict[root].pi_agg = self.nodes_dict[root].cpd.values
-
-        for leaf in self.get_leaves():
-            self.nodes_dict[leaf].lambda_agg = np.ones([self.nodes_dict[leaf].cardinality])
-
-    @property
-    def all_nodes_are_fully_initialized(self):
-        """
-        Returns True if, for all nodes in the model, all lambda and pi
-        messages and lambda_agg and pi_agg are not None, else False.
-        """
-        for node in self.nodes_dict.values():
-            if not node.is_fully_initialized:
-                return False
-        return True
-
-    def copy(self):
-        """
-        Returns a copy of the model.
-        """
-        copy_nodes = copy.deepcopy(self.nodes_dict)
-        copy_model = self.__class__(nodes_dict=copy_nodes)
-        return copy_model
diff --git a/beliefs/models/beliefupdate/BernoulliOrNode.py b/beliefs/models/beliefupdate/BernoulliOrNode.py
deleted file mode 100644
index 3386275..0000000
--- a/beliefs/models/beliefupdate/BernoulliOrNode.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import numpy as np
-from functools import reduce
-
-from beliefs.models.beliefupdate.Node import (
-    Node,
-    MessageType,
-    InvalidLambdaMsgToParent
-)
-from beliefs.factors.BernoulliOrCPD import BernoulliOrCPD
-
-
-class BernoulliOrNode(Node):
-    def __init__(self,
-                 label_id,
-                 children,
-                 parents):
-        super().__init__(label_id=label_id,
-                         children=children,
-                         parents=parents,
-                         cardinality=2,
-                         cpd=BernoulliOrCPD(label_id, parents))
-
-    def compute_pi_agg(self):
-        if not self.parents:
-            self.pi_agg = self.cpd.values
-        else:
-            pi_msg_values = self.validate_and_return_msgs_received_for_msg_type(MessageType.PI)
-            parents_p0 = [p[0] for p in pi_msg_values]
-            p_0 = reduce(lambda x, y: x*y, parents_p0)
-            p_1 = 1 - p_0
-            self.pi_agg = np.array([p_0, p_1])
-        return self.pi_agg
-
-    def compute_lambda_msg_to_parent(self, parent_k):
-        if np.array_equal(self.lambda_agg, np.ones([self.cardinality])):
-            return np.ones([self.cardinality])
-        else:
-            # TODO: cleanup this validation
-            _ = self.validate_and_return_msgs_received_for_msg_type(MessageType.PI)
-            p0_excluding_k = [msg[0] for par_id, msg in self.pi_received_msgs.items() if par_id != parent_k]
-            p0_product = reduce(lambda x, y: x*y, p0_excluding_k, 1)
-            lambda_0 = self.lambda_agg[1] + (self.lambda_agg[0] - self.lambda_agg[1])*p0_product
-            lambda_1 = self.lambda_agg[1]
-            lambda_msg = np.array([lambda_0, lambda_1])
-            if not any(lambda_msg):
-                raise InvalidLambdaMsgToParent
-            return self._normalize(lambda_msg)