Merge pull request #2 from CLMBRs/conv_update

Change encoder_convexity weighted summation

Author: shanest

src/eff_conv/convexity.py

@@ -4,6 +4,8 @@
 
 import numpy as np
 
+from eff_conv.ib.utils import IB_EPSILON
+
 
 class SimilaritySpace:
     """A similarity space contains points (which should correspond in order to referents or meanings) and the priors upon those points.
@@ -29,6 +31,10 @@ def __init__(self, sim_space: np.ndarray, point_prior: np.ndarray = None):
                 or point_prior.shape[0] != sim_space.shape[0]
             ):
                 raise ValueError("Point priors not of correct size")
+            if np.abs(np.sum(point_prior) - 1) > IB_EPSILON:
+                raise ValueError("Point priors must sum to 1")
+            if (point_prior <= 0).any():
+                raise ValueError("Prior values must be greater than 0")
             self.point_prior = point_prior
         else:
             self.point_prior = np.array(
@@ -65,6 +71,10 @@ def quasi_convexity(self, point_dist: np.ndarray, steps: int) -> float:
             raise ValueError("Quasi-Convexity input must be a probability distribution")
         if np.size(point_dist) != self.sim_space.shape[0]:
             raise ValueError("Quasi-Convexity input must map to all points")
+        if np.abs(np.sum(point_dist) - 1) > IB_EPSILON:
+            raise ValueError("Quasi-Convexity input must sum to 1")
+        if (point_dist < 0).any():
+            raise ValueError("Quasi-Convexity input must be greater than or equal to 0")
         if steps <= 0:
             raise ValueError("Steps must be positive")
 
@@ -116,10 +126,10 @@ def quasi_convexity(self, point_dist: np.ndarray, steps: int) -> float:
                 qc += mesh * level.shape[0] / amount
         return qc
 
-    def encoder_convexity(
+    def skinner_encoder_convexity(
         self, distrubitions: np.ndarray, prior: np.ndarray, steps: int = 100
     ) -> float:
-        """Finds the quasi-convexity of a conditional probabilty matrix, typically an IB encoder. Algorithm from Skinner L. (2025).
+        """Finds the quasi-convexity of a conditional probabilty matrix, typically an IB encoder. Weighting algorithm from Skinner L. (2025).
 
         Args:
             distrubitions (np.ndarray): The conditional probaility matrix to be evaluated. Shape is of ||P|| x n where n > 0.
@@ -132,6 +142,11 @@ def encoder_convexity(
             float: The quasi-convexity of the matrix.
         """
 
+        if np.abs(np.sum(prior) - 1) > IB_EPSILON:
+            raise ValueError("Prior must sum to 1")
+        if (prior <= 0).any():
+            raise ValueError("Prior must be greater than 0")
+
         # Apply Bayes' rule
         reconstructed = distrubitions.T * prior[:, None] / self.point_prior
         maximums = np.max(reconstructed, axis=0)
@@ -147,6 +162,32 @@ def encoder_convexity(
             convexities.append(self.quasi_convexity(word, steps))
         return np.sum(np.array(convexities) * weighted_sum)
 
+    def encoder_convexity(
+        self, distrubitions: np.ndarray, prior: np.ndarray, steps: int = 100
+    ) -> float:
+        """Finds the quasi-convexity of a conditional probabilty matrix, typically an IB encoder. Weighting is based on the p(y) for p(x|y).
+
+        Args:
+            distrubitions (np.ndarray): The conditional probaility matrix to be evaluated. Shape is of ||P|| x n where n > 0.
+            Each column of the matrix should be a probability distrubtion over P.
+
+            prior (np.ndarray): The probability distribution of inputs into the encoder. Must be of size n.
+            steps (int, default: 100): The number of steps to interate over the probability (higher is more accurate but slower)
+
+        Returns:
+            float: The quasi-convexity of the matrix.
+        """
+
+        if np.abs(np.sum(prior) - 1) > IB_EPSILON:
+            raise ValueError("Prior must sum to 1")
+        if (prior <= 0).any():
+            raise ValueError("Prior must be greater than 0")
+
+        convexities = []
+        for word in distrubitions.T:
+            convexities.append(self.quasi_convexity(word, steps))
+        return np.sum(np.array(convexities) * prior)
+
     def language_convexity(
         self, lang: IBLanguage, steps: int = 100, referents=False
     ) -> float:

src/eff_conv/ib/language.py

@@ -51,6 +51,10 @@ def __init__(
             raise ValueError(
                 "All columns of conditional probability matrix must sum to 1"
             )
+        if (np.sum(qwm, axis=1) <= 0).any():
+            raise ValueError(
+                "All rows of conditional probability matrix must sum to a value greater than 0"
+            )
         if (qwm < 0).any():
             raise ValueError(
                 "No negative numbers are allowed in the probability matrix"

src/eff_conv/ib/structure.py

@@ -45,7 +45,7 @@ def __init__(
                 )
             if (pum <= 0).any():
                 raise ValueError("Priors must all be greater than 0")
-            if abs(np.sum(prior)) - 1 > IB_EPSILON:
+            if abs(np.sum(prior) - 1) > IB_EPSILON:
                 raise ValueError("Priors must sum to 1")
 
         # If priors are not passed in, make it uniform

src/tests/test_convexity.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 from eff_conv.convexity import SimilaritySpace
 from eff_conv.ib.language import IBLanguage
@@ -32,56 +33,127 @@ class TestConvexity:
     )
 
     # Tests for convexity.py
+    def test_similarity_space_check(self):
+        with pytest.raises(ValueError):
+            space_wrong_shape = SimilaritySpace(np.array([1]))
+        with pytest.raises(ValueError):
+            space_wrong_prior_len = SimilaritySpace(
+                np.array([[1]]), point_prior=np.array([1, 2])
+            )
+        with pytest.raises(ValueError):
+            space_wrong_prior_shape = SimilaritySpace(
+                np.array([[1]]), point_prior=np.array([[1]])
+            )
+        with pytest.raises(ValueError):
+            space_invalid_prior = SimilaritySpace(
+                np.array([[1], [2]]), point_prior=np.array([1, 2])
+            )
+        with pytest.raises(ValueError):
+            space_zero_prior = SimilaritySpace(
+                np.array([[1], [2]]), point_prior=np.array([1, 0])
+            )
+        with pytest.raises(ValueError):
+            space_negative_prior = SimilaritySpace(
+                np.array([[1], [2]]), point_prior=np.array([2, -1])
+            )
+
     def test_convexity_calculation(self):
         assert (
-            self.sim_space.encoder_convexity(np.ones((9, 1)) / 9, np.array([1])) - 1
+            abs(
+                self.sim_space.encoder_convexity(np.ones((9, 1)) / 9, np.array([1])) - 1
+            )
             < IB_EPSILON
         )
         # Epsilon is higher because rounding errors are more common beacuse of the nature of the algorithm
         assert (
-            self.sim_space.encoder_convexity(
-                np.array([[0.2], [0], [0.2], [0], [0.2], [0], [0.2], [0], [0.2]]),
-                np.array([1]),
+            abs(
+                self.sim_space.skinner_encoder_convexity(
+                    np.array(
+                        [
+                            # fmt: off
+                        [0.2, 0],
+                        [0,   1],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                            # fmt: on
+                        ]
+                    ),
+                    np.array([0.5, 0.5]),
+                )
+                - 19 / 27
+            )
+            < 0.005
+        )
+        assert (
+            abs(
+                self.sim_space.encoder_convexity(
+                    np.array(
+                        [
+                            # fmt: off
+                        [0.2, 0],
+                        [0,   1],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                        [0,   0],
+                        [0.2, 0],
+                            # fmt: on
+                        ]
+                    ),
+                    np.array([0.5, 0.5]),
+                )
+                - 14 / 18
             )
-            - 5 / 9
             < 0.005
         )
 
     def test_projection_down(self):
         # This also tests 1d spaces
         assert (
-            self.sim_space_large.encoder_convexity(
-                np.array(
-                    [
-                        # fmt: off
+            abs(
+                self.sim_space_large.encoder_convexity(
+                    np.array(
+                        [
+                            # fmt: off
                         [0.33], [0], [0], [0],
                         [0],    [0], [0], [0],
                         [0.33], [0], [0], [0],
                         [0.33], [0], [0], [0],
-                        # fmt: on
-                    ]
-                ),
-                np.array([1]),
+                            # fmt: on
+                        ]
+                    )
+                    / 0.99,
+                    np.array([1]),
+                )
+                - 3 / 4
             )
-            - 3 / 4
             < 0.005
         )
         assert (
-            self.sim_space_large.encoder_convexity(
-                np.array(
-                    [
-                        # fmt: off
+            abs(
+                self.sim_space_large.encoder_convexity(
+                    np.array(
+                        [
+                            # fmt: off
                         [0.5], [0], [0], [0],
                         [0],   [0], [0], [0],
                         [0],   [0], [0], [0],
                         [0.5], [0], [0], [0],
-                        # fmt: on
-                    ]
-                ),
-                np.array([1]),
-                steps=1000,
+                            # fmt: on
+                        ]
+                    ),
+                    np.array([1]),
+                    steps=1000,
+                )
+                - 1 / 2
             )
-            - 1 / 2
             < 0.005
         )
 
@@ -96,17 +168,57 @@ def test_language_convexity(self):
         )
         simple_lang = IBLanguage(simple_struct, np.ones((1, 9)))
         assert (
-            self.sim_space.language_convexity(simple_lang)
-            - self.sim_space.encoder_convexity(np.ones((9, 1)) / 9, np.array([1]))
+            abs(
+                self.sim_space.language_convexity(simple_lang)
+                - self.sim_space.encoder_convexity(np.ones((9, 1)) / 9, np.array([1]))
+            )
             < IB_EPSILON
         )
         # This will fail on remote if the epsilon is not higher
         assert (
-            self.sim_space.language_convexity(simple_lang, referents=True, steps=1000)
-            - self.sim_space.encoder_convexity(
-                np.array([[0.465, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.465]]).T,
-                np.array([1]),
-                steps=1000,
+            abs(
+                self.sim_space.language_convexity(
+                    simple_lang, referents=True, steps=1000
+                )
+                - self.sim_space.encoder_convexity(
+                    np.array(
+                        [[0.465, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.465]]
+                    ).T,
+                    np.array([1]),
+                    steps=1000,
+                )
             )
             < 0.005
         )
+
+    def test_convexity_check(self):
+        with pytest.raises(ValueError):
+            input_wrong_shape = self.sim_space.quasi_convexity(np.ones((9, 1)), 100)
+        with pytest.raises(ValueError):
+            input_wrong_size = self.sim_space.quasi_convexity(np.ones(8) / 8, 100)
+        with pytest.raises(ValueError):
+            input_invalid = self.sim_space.quasi_convexity(np.ones(9), 100)
+        with pytest.raises(ValueError):
+            input_negative = self.sim_space.quasi_convexity(
+                np.array([-7, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 100
+            )
+        with pytest.raises(ValueError):
+            steps_negative = self.sim_space.quasi_convexity(np.ones(9) / 9, -1)
+
+    def test_encoder_check(self):
+        with pytest.raises(ValueError):
+            prior_invalid = self.sim_space.encoder_convexity(
+                np.ones((9, 1)) / 9, np.array([0.9])
+            )
+        with pytest.raises(ValueError):
+            prior_invalid_skinner = self.sim_space.skinner_encoder_convexity(
+                np.ones((9, 1)) / 9, np.array([0.9])
+            )
+        with pytest.raises(ValueError):
+            prior_negative = self.sim_space.encoder_convexity(
+                np.ones((9, 2)) / 9, np.array([-1, 2])
+            )
+        with pytest.raises(ValueError):
+            prior_negative_skinner = self.sim_space.skinner_encoder_convexity(
+                np.ones((9, 2)) / 9, np.array([-1, 2])
+            )

src/tests/test_ib.py

@@ -55,6 +55,10 @@ def test_ib_structure_check(self):
             struct_invalid_prior = IBStructure(
                 np.array([[0.25, 0.25, 0.25, 0.25]]), np.array([1, 2, 3, 4])
             )
+        with pytest.raises(ValueError):
+            struct_small_prior = IBStructure(
+                np.array([[0.25, 0.25, 0.25, 0.25]]), np.array([0.1, 0.1, 0.1, 0.1])
+            )
 
     # Tests for utils.py
     def test_safe_log(self):
@@ -182,3 +186,5 @@ def test_ib_language_check(self):
             lang_negative_probability = IBLanguage(
                 self.simple_struct, np.array([[-1, 1], [2, 0]])
             )
+        with pytest.raises(ValueError):
+            lang_zero_row = IBLanguage(self.simple_struct, np.array([[1, 1], [0, 0]]))