compiled-knowledge 4.0.0a20__cp313-cp313-macosx_10_13_x86_64.whl

ck/example/child.py

@@ -0,0 +1,199 @@
+from ck.pgm import PGM
+
+
+class Child(PGM):
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        pgm_rv0 = self.new_rv('BirthAsphyxia', ('yes', 'no'))
+        pgm_rv1 = self.new_rv('HypDistrib', ('Equal', 'Unequal'))
+        pgm_rv2 = self.new_rv('HypoxiaInO2', ('Mild', 'Moderate', 'Severe'))
+        pgm_rv3 = self.new_rv('CO2', ('Normal', 'Low', 'High'))
+        pgm_rv4 = self.new_rv('ChestXray', ('Normal', 'Oligaemic', 'Plethoric', 'Grd_Glass', 'Asy/Patch'))
+        pgm_rv5 = self.new_rv('Grunting', ('yes', 'no'))
+        pgm_rv6 = self.new_rv('LVHreport', ('yes', 'no'))
+        pgm_rv7 = self.new_rv('LowerBodyO2', ('<5', '5-12', '12+'))
+        pgm_rv8 = self.new_rv('RUQO2', ('<5', '5-12', '12+'))
+        pgm_rv9 = self.new_rv('CO2Report', ('<7.5', '>=7.5'))
+        pgm_rv10 = self.new_rv('XrayReport', ('Normal', 'Oligaemic', 'Plethoric', 'Grd_Glass', 'Asy/Patchy'))
+        pgm_rv11 = self.new_rv('Disease', ('PFC', 'TGA', 'Fallot', 'PAIVS', 'TAPVD', 'Lung'))
+        pgm_rv12 = self.new_rv('GruntingReport', ('yes', 'no'))
+        pgm_rv13 = self.new_rv('Age', ('0-3_days', '4-10_days', '11-30_days'))
+        pgm_rv14 = self.new_rv('LVH', ('yes', 'no'))
+        pgm_rv15 = self.new_rv('DuctFlow', ('Lt_to_Rt', 'None', 'Rt_to_Lt'))
+        pgm_rv16 = self.new_rv('CardiacMixing', ('None', 'Mild', 'Complete', 'Transp.'))
+        pgm_rv17 = self.new_rv('LungParench', ('Normal', 'Congested', 'Abnormal'))
+        pgm_rv18 = self.new_rv('LungFlow', ('Normal', 'Low', 'High'))
+        pgm_rv19 = self.new_rv('Sick', ('yes', 'no'))
+        pgm_factor0 = self.new_factor(pgm_rv0)
+        pgm_factor1 = self.new_factor(pgm_rv1, pgm_rv15, pgm_rv16)
+        pgm_factor2 = self.new_factor(pgm_rv2, pgm_rv16, pgm_rv17)
+        pgm_factor3 = self.new_factor(pgm_rv3, pgm_rv17)
+        pgm_factor4 = self.new_factor(pgm_rv4, pgm_rv17, pgm_rv18)
+        pgm_factor5 = self.new_factor(pgm_rv5, pgm_rv17, pgm_rv19)
+        pgm_factor6 = self.new_factor(pgm_rv6, pgm_rv14)
+        pgm_factor7 = self.new_factor(pgm_rv7, pgm_rv1, pgm_rv2)
+        pgm_factor8 = self.new_factor(pgm_rv8, pgm_rv2)
+        pgm_factor9 = self.new_factor(pgm_rv9, pgm_rv3)
+        pgm_factor10 = self.new_factor(pgm_rv10, pgm_rv4)
+        pgm_factor11 = self.new_factor(pgm_rv11, pgm_rv0)
+        pgm_factor12 = self.new_factor(pgm_rv12, pgm_rv5)
+        pgm_factor13 = self.new_factor(pgm_rv13, pgm_rv11, pgm_rv19)
+        pgm_factor14 = self.new_factor(pgm_rv14, pgm_rv11)
+        pgm_factor15 = self.new_factor(pgm_rv15, pgm_rv11)
+        pgm_factor16 = self.new_factor(pgm_rv16, pgm_rv11)
+        pgm_factor17 = self.new_factor(pgm_rv17, pgm_rv11)
+        pgm_factor18 = self.new_factor(pgm_rv18, pgm_rv11)
+        pgm_factor19 = self.new_factor(pgm_rv19, pgm_rv11)
+        
+        pgm_function0 = pgm_factor0.set_dense()
+        pgm_function0.set_flat(0.1, 0.9)
+        
+        pgm_function1 = pgm_factor1.set_dense()
+        pgm_function1.set_flat(
+            0.95, 0.95, 0.95, 0.95, 0.95, 
+            0.95, 0.95, 0.95, 0.05, 0.5, 
+            0.95, 0.5, 0.05, 0.05, 0.05, 
+            0.05, 0.05, 0.05, 0.05, 0.05, 
+            0.95, 0.5, 0.05, 0.5
+        )
+        
+        pgm_function2 = pgm_factor2.set_dense()
+        pgm_function2.set_flat(
+            0.93, 0.15, 0.7, 0.1, 0.1, 
+            0.1, 0.1, 0.05, 0.1, 0.02, 
+            0.1, 0.02, 0.05, 0.8, 0.2, 
+            0.8, 0.75, 0.65, 0.7, 0.65, 
+            0.5, 0.18, 0.3, 0.18, 0.02, 
+            0.05, 0.1, 0.1, 0.15, 0.25, 
+            0.2, 0.3, 0.4, 0.8, 0.6, 
+            0.8
+        )
+        
+        pgm_function3 = pgm_factor3.set_dense()
+        pgm_function3.set_flat(
+            0.8, 0.65, 0.45, 0.1, 0.05, 
+            0.05, 0.1, 0.3, 0.5
+        )
+        
+        pgm_function4 = pgm_factor4.set_dense()
+        pgm_function4.set_flat(
+            0.9, 0.14, 0.15, 0.05, 0.05, 
+            0.05, 0.05, 0.05, 0.24, 0.03, 
+            0.8, 0.01, 0.02, 0.22, 0.02, 
+            0.05, 0.15, 0.33, 0.03, 0.02, 
+            0.79, 0.15, 0.08, 0.4, 0.05, 
+            0.05, 0.03, 0.01, 0.02, 0.04, 
+            0.7, 0.5, 0.4, 0.05, 0.05, 
+            0.34, 0.03, 0.02, 0.01, 0.08, 
+            0.15, 0.13, 0.8, 0.7, 0.06
+        )
+        
+        pgm_function5 = pgm_factor5.set_dense()
+        pgm_function5.set_flat(
+            0.2, 0.05, 0.4, 0.2, 0.8, 
+            0.6, 0.8, 0.95, 0.6, 0.8, 
+            0.2, 0.4
+        )
+        
+        pgm_function6 = pgm_factor6.set_dense()
+        pgm_function6.set_flat(0.9, 0.05, 0.1, 0.95)
+        
+        pgm_function7 = pgm_factor7.set_dense()
+        pgm_function7.set_flat(
+            0.1, 0.3, 0.5, 0.4, 0.5, 
+            0.6, 0.3, 0.6, 0.4, 0.5, 
+            0.45, 0.35, 0.6, 0.1, 0.1, 
+            0.1, 0.05, 0.05
+        )
+        
+        pgm_function8 = pgm_factor8.set_dense()
+        pgm_function8.set_flat(
+            0.1, 0.3, 0.5, 0.3, 0.6, 
+            0.4, 0.6, 0.1, 0.1
+        )
+        
+        pgm_function9 = pgm_factor9.set_dense()
+        pgm_function9.set_flat(
+            0.9, 0.9, 0.1, 0.1, 0.1, 
+            0.9
+        )
+        
+        pgm_function10 = pgm_factor10.set_dense()
+        pgm_function10.set_flat(
+            0.8, 0.1, 0.1, 0.08, 0.08, 
+            0.06, 0.8, 0.02, 0.02, 0.02, 
+            0.06, 0.02, 0.8, 0.1, 0.1, 
+            0.02, 0.02, 0.02, 0.6, 0.1, 
+            0.06, 0.06, 0.06, 0.2, 0.7
+        )
+        
+        pgm_function11 = pgm_factor11.set_dense()
+        pgm_function11.set_flat(
+            0.2, 0.03061224, 0.3, 0.33673469, 0.25, 
+            0.29591837, 0.15, 0.23469388, 0.05, 0.05102041, 
+            0.05, 0.05102041
+        )
+        
+        pgm_function12 = pgm_factor12.set_dense()
+        pgm_function12.set_flat(0.8, 0.1, 0.2, 0.9)
+        
+        pgm_function13 = pgm_factor13.set_dense()
+        pgm_function13.set_flat(
+            0.95, 0.85, 0.8, 0.7, 0.7, 
+            0.25, 0.8, 0.8, 0.8, 0.7, 
+            0.9, 0.8, 0.03, 0.1, 0.15, 
+            0.2, 0.15, 0.25, 0.15, 0.15, 
+            0.15, 0.2, 0.08, 0.15, 0.02, 
+            0.05, 0.05, 0.1, 0.15, 0.5, 
+            0.05, 0.05, 0.05, 0.1, 0.02, 
+            0.05
+        )
+        
+        pgm_function14 = pgm_factor14.set_dense()
+        pgm_function14.set_flat(
+            0.1, 0.1, 0.1, 0.9, 0.05, 
+            0.1, 0.9, 0.9, 0.9, 0.1, 
+            0.95, 0.9
+        )
+        
+        pgm_function15 = pgm_factor15.set_dense()
+        pgm_function15.set_flat(
+            0.15, 0.1, 0.8, 1.0, 0.33, 
+            0.2, 0.05, 0.8, 0.2, 0.0, 
+            0.33, 0.4, 0.8, 0.1, 0.0, 
+            0.0, 0.34, 0.4
+        )
+        
+        pgm_function16 = pgm_factor16.set_dense()
+        pgm_function16.set_flat(
+            0.4, 0.02, 0.02, 0.01, 0.01, 
+            0.4, 0.43, 0.09, 0.16, 0.02, 
+            0.03, 0.53, 0.15, 0.09, 0.8, 
+            0.95, 0.95, 0.05, 0.02, 0.8, 
+            0.02, 0.02, 0.01, 0.02
+        )
+        
+        pgm_function17 = pgm_factor17.set_dense()
+        pgm_function17.set_flat(
+            0.6, 0.8, 0.8, 0.8, 0.1, 
+            0.03, 0.1, 0.05, 0.05, 0.05, 
+            0.6, 0.25, 0.3, 0.15, 0.15, 
+            0.15, 0.3, 0.72
+        )
+        
+        pgm_function18 = pgm_factor18.set_dense()
+        pgm_function18.set_flat(
+            0.3, 0.2, 0.15, 0.1, 0.3, 
+            0.7, 0.65, 0.05, 0.8, 0.85, 
+            0.1, 0.1, 0.05, 0.75, 0.05, 
+            0.05, 0.6, 0.2
+        )
+        
+        pgm_function19 = pgm_factor19.set_dense()
+        pgm_function19.set_flat(
+            0.4, 0.3, 0.2, 0.3, 0.7, 
+            0.7, 0.6, 0.7, 0.8, 0.7, 
+            0.3, 0.3
+        )

ck/example/clique.py

@@ -0,0 +1,33 @@
+import random as _random
+
+from ck.pgm import PGM
+
+
+class Clique(PGM):
+    """
+    This PGM is the 'Clique' factor graph.
+
+    The Clique factor graph has one factor that connects to all random variables.
+    Random variables are named x0, x1, x2, ... .
+    If include_unaries then, also includes one unary factor per random variable.
+    """
+
+    def __init__(
+            self,
+            vars_per_clique: int = 17,
+            states_per_var: int = 2,
+            include_unaries: bool = True,
+            random_seed: int = 123456,
+    ):
+        params = (vars_per_clique, states_per_var, include_unaries)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random_stream = _random.Random(random_seed).random
+
+        rvs = [self.new_rv(f'x{i}', states_per_var) for i in range(vars_per_clique)]
+
+        self.new_factor(*rvs).set_dense().set_stream(random_stream)
+
+        if include_unaries:
+            for rv in rvs:
+                self.new_factor(rv).set_dense().set_stream(random_stream)

ck/example/cnf_pgm.py

@@ -0,0 +1,39 @@
+import random as _random
+
+from ck.pgm import PGM
+from ck.utils.random_extras import random_permutation as _random_permutation
+
+
+class CNF_PGM(PGM):
+    """
+    This is a PGM that uses a factor graph to represent a
+    CNF propositional theory.
+
+    A CNF_PGM factor graph has random clause factors.
+    Random variables are named x0, x1, x2, ... .
+    """
+
+    def __init__(
+            self,
+            num_vars: int = 30,
+            num_clauses: int = 200,
+            min_clause_size: int = 3,
+            max_clause_size: int = 5,
+            random_seed: int = 129837697,
+    ):
+        params = (num_vars, num_clauses, min_clause_size, max_clause_size)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random = _random.Random(random_seed)
+
+        for i in range(num_vars):
+            self.new_rv(f'x{i}', 2)
+
+        pgm_rvs = self.rvs
+        for i in range(num_clauses):
+            size = random.randint(min_clause_size, max_clause_size)
+            perm = _random_permutation(num_vars, random)
+            rvs = tuple(pgm_rvs[j] for j in perm[:size])
+            states = [random.randint(0, 1) for _ in range(size)]
+
+            self.new_factor(*rvs).set_clause(*states)

ck/example/diamond_square.py

@@ -0,0 +1,68 @@
+import random as _random
+
+from ck.pgm import PGM
+
+
+class DiamondSquare(PGM):
+    r"""
+    This PGM is the 'DiamondSquare' factor graph.
+
+    The DiamondSquare is a factor graph with seven random variables (a, b, c, ..., h).
+    Binary factors are between pairs of random variables creating the pattern:
+                     b
+                    / \
+                   /   \
+                  c -- d
+                / |    | \
+               a  |    |  h
+                \ |    | /
+                  e -- f
+                  \   /
+                   \ /
+                    g
+    If include_unaries then, also includes one unary factor per random variable.
+    """
+
+    def __init__(
+            self,
+            states_per_var: int = 5,
+            include_unaries: bool = True,
+            random_seed: int = 123456,
+    ):
+        params = (states_per_var, include_unaries)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random_stream = _random.Random(random_seed).random
+        rand_iter = iter(random_stream, None)
+
+        a = self.new_rv('a', states_per_var)
+        b = self.new_rv('b', states_per_var)
+        c = self.new_rv('c', states_per_var)
+        d = self.new_rv('d', states_per_var)
+        e = self.new_rv('e', states_per_var)
+        f = self.new_rv('f', states_per_var)
+        g = self.new_rv('g', states_per_var)
+        h = self.new_rv('h', states_per_var)
+
+        self.new_factor(a, c).set_dense().set_iter(rand_iter)
+        self.new_factor(a, e).set_dense().set_iter(rand_iter)
+        self.new_factor(b, c).set_dense().set_iter(rand_iter)
+        self.new_factor(b, d).set_dense().set_iter(rand_iter)
+        self.new_factor(g, e).set_dense().set_iter(rand_iter)
+        self.new_factor(g, f).set_dense().set_iter(rand_iter)
+        self.new_factor(h, d).set_dense().set_iter(rand_iter)
+        self.new_factor(h, f).set_dense().set_iter(rand_iter)
+        self.new_factor(c, d).set_dense().set_iter(rand_iter)
+        self.new_factor(c, e).set_dense().set_iter(rand_iter)
+        self.new_factor(d, f).set_dense().set_iter(rand_iter)
+        self.new_factor(e, f).set_dense().set_iter(rand_iter)
+
+        if include_unaries:
+            self.new_factor(a).set_dense().set_iter(rand_iter)
+            self.new_factor(b).set_dense().set_iter(rand_iter)
+            self.new_factor(c).set_dense().set_iter(rand_iter)
+            self.new_factor(d).set_dense().set_iter(rand_iter)
+            self.new_factor(e).set_dense().set_iter(rand_iter)
+            self.new_factor(f).set_dense().set_iter(rand_iter)
+            self.new_factor(g).set_dense().set_iter(rand_iter)
+            self.new_factor(h).set_dense().set_iter(rand_iter)

ck/example/earthquake.py

@@ -0,0 +1,36 @@
+from ck.pgm import PGM
+
+
+class Earthquake(PGM):
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        pgm_rv0 = self.new_rv('Burglary', ('True', 'False'))
+        pgm_rv1 = self.new_rv('Earthquake', ('True', 'False'))
+        pgm_rv2 = self.new_rv('Alarm', ('True', 'False'))
+        pgm_rv3 = self.new_rv('JohnCalls', ('True', 'False'))
+        pgm_rv4 = self.new_rv('MaryCalls', ('True', 'False'))
+        pgm_factor0 = self.new_factor(pgm_rv0)
+        pgm_factor1 = self.new_factor(pgm_rv1)
+        pgm_factor2 = self.new_factor(pgm_rv2, pgm_rv0, pgm_rv1)
+        pgm_factor3 = self.new_factor(pgm_rv3, pgm_rv2)
+        pgm_factor4 = self.new_factor(pgm_rv4, pgm_rv2)
+
+        pgm_function0 = pgm_factor0.set_dense()
+        pgm_function0.set_flat(0.01, 0.99)
+
+        pgm_function1 = pgm_factor1.set_dense()
+        pgm_function1.set_flat(0.02, 0.98)
+
+        pgm_function2 = pgm_factor2.set_dense()
+        pgm_function2.set_flat(
+            0.95, 0.94, 0.29, 0.001, 0.05,
+            0.06, 0.71, 0.999
+        )
+
+        pgm_function3 = pgm_factor3.set_dense()
+        pgm_function3.set_flat(0.9, 0.05, 0.1, 0.95)
+
+        pgm_function4 = pgm_factor4.set_dense()
+        pgm_function4.set_flat(0.7, 0.01, 0.3, 0.99)

ck/example/empty.py

@@ -0,0 +1,10 @@
+from ck.pgm import PGM
+
+
+class Empty(PGM):
+    """
+    This PGM has no random variables.
+    """
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)