Move max_message to correct level of abstraction. Updated version and…

… requirements.txt.

requirements.txt

@@ -1,4 +1,4 @@
-networkx>=3.2.1
+networkx>=3.0
 numpy>=1.24.4
 random_events>=1.1.1
 tabulate>=0.9.0

src/fglib2/__init__.py

@@ -1 +1 @@
-__version__ = '1.1.0'
+__version__ = '1.1.1'

src/fglib2/distributions.py

@@ -3,7 +3,7 @@
 
 import numpy as np
 
-from random_events.variables import Discrete, Symbolic
+from random_events.variables import Discrete
 from random_events.events import Event, EncodedEvent
 
 import tabulate
@@ -205,25 +205,6 @@ def likelihood(self, event: List) -> float:
         """
         return self._likelihood(self.encode(event))
 
-    def max_message(self, variable) -> 'Multinomial':
-        """
-        Construct a message that contains the maximum likelihood for each value of the variable.
-
-        .. Note::
-            The message is not normalized. The reason is the purpose of a max message. In every entry of the
-            `probabilities` array is the maximum possible likelihood for the corresponding event. Therefore,
-            this message should not be normalized.
-
-        :param variable: The variable to construct it over.
-        :return: A not normalized distribution over the variable with the maximum likelihood for each value.
-        """
-        if variable not in self.variables:
-            raise ValueError("The variable {} is not in the distribution."
-                             "The distributions variables are {}".format(variable, self.variables))
-        axis = tuple(index for index, var in enumerate(self.variables) if var != variable)
-        probabilities = np.max(self.probabilities, axis=axis)
-        return Multinomial([variable], probabilities)
-
     def _conditional(self, event: EncodedEvent) -> 'Multinomial':
         """
         Calculate the conditional distribution given an event encoded.

src/fglib2/graphs.py

@@ -111,6 +111,25 @@ def __mul__(self, other: 'FactorNode') -> 'FactorGraph':
         """
         return FactorGraph() * self * other
 
+    def max_message(self, variable) -> 'Multinomial':
+        """
+        Construct a message that contains the maximum likelihood for each value of the variable.
+
+        .. Note::
+            The message is not normalized. The reason is the purpose of a max message. In every entry of the
+            `probabilities` array is the maximum possible likelihood for the corresponding event. Therefore,
+            this message should not be normalized.
+
+        :param variable: The variable to construct it over.
+        :return: A not normalized distribution over the variable with the maximum likelihood for each value.
+        """
+        if variable not in self.variables:
+            raise ValueError("The variable {} is not in the distribution."
+                             "The distributions variables are {}".format(variable, self.variables))
+        axis = tuple(index for index, var in enumerate(self.variables) if var != variable)
+        probabilities = np.max(self.distribution.probabilities, axis=axis)
+        return Multinomial([variable], probabilities)
+
 
 class Edge:
     """
@@ -318,7 +337,7 @@ def max_product(self) -> Event:
                                      self.neighbors(source) if neighbour != target]
                 msg = source.sum_product(incoming_messages)
 
-                msg = msg.max_message(target.variable)
+                msg = FactorNode(msg).max_message(target.variable)
                 self.edges[source, target]['edge'].factor_to_variable = msg
 
         for source, target in backtracking_path:
@@ -345,7 +364,7 @@ def max_product(self) -> Event:
                                      self.neighbors(source)]
                 msg = source.sum_product(incoming_messages)
 
-                msg = msg.max_message(target.variable)
+                msg = FactorNode(msg).max_message(target.variable)
                 self.edges[source, target]['edge'].factor_to_variable = msg
 
         result = Event()

test/test_distributions.py

@@ -160,18 +160,6 @@ def test_multiple_modes(self):
         self.assertEqual(mode[1]["X"], (1,))
         self.assertEqual(mode[1]["Y"], (0,))
 
-    def test_random_max_message(self):
-        max_message = self.random_distribution.max_message(self.z)
-        self.assertEqual(max_message.probabilities.shape, (5, ))
-
-    def test_crafted_max_message(self):
-        max_message = self.crafted_distribution.max_message(self.x)
-        self.assertTrue(np.allclose(max_message.probabilities, np.array([0.3, 0.7])))
-
-    def test_max_message_wrong_variable(self):
-        with self.assertRaises(ValueError):
-            self.crafted_distribution.max_message(self.z)
-
     def test_crafted_probability(self):
         distribution = self.crafted_distribution.normalize()
         event = Event()
@@ -270,5 +258,6 @@ def test_disjoint_variables(self):
         with self.assertRaises(AssertionError):
             self.distribution_x * self.distribution_y
 
+
 if __name__ == '__main__':
     unittest.main()

test/test_graphs.py

@@ -12,6 +12,39 @@
 from random_events.variables import Symbolic
 
 
+class FactorNodeTestCase(unittest.TestCase):
+    x: Symbolic
+    y: Symbolic
+    z: Symbolic
+    random_factor_node: FactorNode
+    crafted_factor_node: FactorNode
+
+    @classmethod
+    def setUpClass(cls):
+        np.random.seed(69)
+        cls.x = Symbolic("X", range(2))
+        cls.y = Symbolic("Y", range(3))
+        cls.z = Symbolic("Z", range(5))
+        cls.random_factor_node = FactorNode(Multinomial([cls.x, cls.y, cls.z], np.random.rand(len(cls.x.domain),
+                                                                                              len(cls.y.domain),
+                                                                                              len(cls.z.domain))))
+
+        cls.crafted_factor_node = (
+            FactorNode(Multinomial([cls.x, cls.y], np.array([[0.1, 0.2, 0.3], [0.7, 0.4, 0.1]]))))
+
+    def test_random_max_message(self):
+        max_message = self.random_factor_node.max_message(self.z)
+        self.assertEqual(max_message.probabilities.shape, (5, ))
+
+    def test_crafted_max_message(self):
+        max_message = self.crafted_factor_node.max_message(self.x)
+        self.assertTrue(np.allclose(max_message.probabilities, np.array([0.3, 0.7])))
+
+    def test_max_message_wrong_variable(self):
+        with self.assertRaises(ValueError):
+            self.crafted_factor_node.max_message(self.z)
+
+
 class FactorGraphTestCase(unittest.TestCase):
     x: Symbolic
     y: Symbolic
@@ -187,9 +220,9 @@ def test_latex_equation(self):
     def test_max_product(self):
         mode = self.graph.max_product()
         self.assertEqual(mode[self.x1], (0, 1))
-        self.assertEqual(mode[self.x2], (0, ))
-        self.assertEqual(mode[self.x3], (1, ))
-        self.assertEqual(mode[self.x4], (1, ))
+        self.assertEqual(mode[self.x2], (0,))
+        self.assertEqual(mode[self.x3], (1,))
+        self.assertEqual(mode[self.x4], (1,))
 
 
 if __name__ == "__main__":