compiled-knowledge 4.1.0a2__cp312-cp312-win32.whl → 4.1.0a3__cp312-cp312-win32.whl

ck/probability/probability_space.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import math
 from abc import ABC, abstractmethod
 from itertools import chain
@@ -203,16 +205,19 @@ class ProbabilitySpace(ABC):
                 loop_rvs.append([rv[i] for i in sorted(states)])
                 reduced_space = True
 
+        best_probability = float('-inf')
+        best_states = None
+
         # If the random variables we are looping over does not have any conditions
         # then it is expected to be faster by using computed marginal probabilities.
         if not reduced_space:
             prs = self.marginal_distribution(*rvs, condition=condition)
-            best_probability = float('-inf')
-            best_states = None
             for probability, inst in zip(prs, rv_instances(*rvs)):
                 if probability > best_probability:
                     best_probability = probability
                     best_states = inst
+            if best_states is None:
+                return _NAN, ()
             return best_probability, best_states
 
         else:
@@ -220,8 +225,6 @@ class ProbabilitySpace(ABC):
             new_conditions = tuple(ind for ind in condition if ind.rv_idx not in rv_indexes)
 
             # Loop over the state space of the 'loop' rvs
-            best_probability = float('-inf')
-            best_states = None
             indicators: Tuple[Indicator, ...]
             for indicators in _combos(loop_rvs):
                 probability = self.wmc(*(indicators + new_conditions))
@@ -229,6 +232,8 @@ class ProbabilitySpace(ABC):
                     best_probability = probability
                     best_states = tuple(ind.state_idx for ind in indicators)
             condition_probability = self.wmc(*condition)
+            if best_states is None:
+                return _NAN, ()
             return best_probability / condition_probability, best_states
 
     def correlation(self, indicator1: Indicator, indicator2: Indicator, condition: Condition = ()) -> float:
@@ -245,6 +250,20 @@ class ProbabilitySpace(ABC):
         """
         condition = check_condition(condition)
 
+        if indicator1.rv_idx == indicator2.rv_idx:
+            # Special case - same random variable
+            condition_groups: MapSet[int, Indicator] = _group_indicators(condition)
+            rv_idx: int = indicator1.rv_idx
+            if indicator1 not in condition_groups.get(rv_idx, (indicator1,)):
+                return _NAN
+            if indicator1 == indicator2:
+                return 1
+            else:
+                if indicator2 not in condition_groups.get(rv_idx, (indicator2,)):
+                    return _NAN
+                else:
+                    return 0
+
         p1 = self.probability(indicator1, condition=condition)
         p2 = self.probability(indicator2, condition=condition)
         p12 = self._joint_probability(indicator1, indicator2, condition=condition)
@@ -267,12 +286,7 @@ class ProbabilitySpace(ABC):
             entropy of the given random variable.
         """
         condition = check_condition(condition)
-        e = 0.0
-        for ind in rv:
-            p = self.probability(ind, condition=condition)
-            if p > 0.0:
-                e -= p * math.log2(p)
-        return e
+        return -sum(plogp(self.probability(ind, condition=condition)) for ind in rv)
 
     def conditional_entropy(self, rv1: RandomVariable, rv2: RandomVariable, condition: Condition = ()) -> float:
         """
@@ -309,13 +323,11 @@ class ProbabilitySpace(ABC):
             joint entropy of the given random variables.
         """
         condition = check_condition(condition)
-        e = 0.0
-        for ind1 in rv1:
-            for ind2 in rv2:
-                p = self._joint_probability(ind1, ind2, condition=condition)
-                if p > 0.0:
-                    e -= p * math.log2(p)
-        return e
+        return -sum(
+            plogp(self._joint_probability(ind1, ind2, condition=condition))
+            for ind1 in rv1
+            for ind2 in rv2
+        )
 
     def mutual_information(self, rv1: RandomVariable, rv2: RandomVariable, condition: Condition = ()) -> float:
         """
@@ -419,8 +431,12 @@ class ProbabilitySpace(ABC):
         denominator = self.joint_entropy(rv1, rv2, condition=condition)
         return self._normalised_mutual_information(rv1, rv2, denominator, condition=condition)
 
-    def covariant_normalised_mutual_information(self, rv1: RandomVariable, rv2: RandomVariable,
-                                                condition: Condition = ()) -> float:
+    def covariant_normalised_mutual_information(
+            self,
+            rv1: RandomVariable,
+            rv2: RandomVariable,
+            condition: Condition = (),
+    ) -> float:
         """
         Calculate the covariant normalised mutual information
         = I(rv1; rv2) / sqrt(H(rv1) * H(rv2)).
@@ -549,6 +565,14 @@ class ProbabilitySpace(ABC):
         return wmc
 
 
+def plogp(p: float) -> float:
+    """
+    Returns:
+        p * log2(p)
+    """
+    return p * math.log2(p) if p > 0 else 0
+
+
 def check_condition(condition: Condition) -> Tuple[Indicator, ...]:
     """
     Make the best effort to interpret the given condition.

ck_demos/dataset/demo_dataset_from_sampler.py

@@ -0,0 +1,18 @@
+from ck import example
+from ck.dataset.sampled_dataset import dataset_from_sampler
+from ck.pgm import PGM
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+from ck.sampling.sampler import Sampler
+
+
+def main() -> None:
+    pgm: PGM = example.Student()
+    sampler: Sampler = WMCProgram(DEFAULT_PGM_COMPILER(pgm)).sample_direct()
+    dataset = dataset_from_sampler(sampler, 10)
+
+    dataset.dump()
+
+
+if __name__ == '__main__':
+    main()

ck_demos/learning/demo_bayesian_network_from_cross_tables.py

@@ -0,0 +1,71 @@
+from typing import List, Set
+
+from ck import example
+from ck.dataset import HardDataset
+from ck.dataset.cross_table import CrossTable, cross_table_from_hard_dataset
+from ck.dataset.sampled_dataset import dataset_from_sampler
+from ck.learning.model_from_cross_tables import model_from_cross_tables
+from ck.pgm import PGM, RandomVariable
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+from ck.probability import divergence
+
+EXCLUDE_UNNECESSARY_CROSS_TABLES = True
+
+
+def main() -> None:
+    number_of_samples: int = 10000  # How many instances to make for the model dataset
+
+    # Create a dataset based on model which is an example PGM
+    model: PGM = example.Student()
+    model_dataset = dataset_from_sampler(
+        WMCProgram(DEFAULT_PGM_COMPILER(model)).sample_direct(),
+        number_of_samples,
+    )
+
+    # Clone the model, without factors, and transport the dataset to the new PGM
+    pgm = PGM()
+    dataset = HardDataset(weights=model_dataset.weights)
+    for model_rv in model.rvs:
+        rv = pgm.new_rv(model_rv.name, model_rv.states)
+        dataset.add_rv_from_state_idxs(rv, model_dataset.state_idxs(model_rv))
+
+    # What model rvs have a child
+    model_rvs_with_children: Set[RandomVariable] = set()
+    for model_factor in model.factors:
+        for parent_rv in model_factor.rvs[1:]:
+            model_rvs_with_children.add(parent_rv)
+
+    # Construct cross-tables from the dataset
+    cross_tables: List[CrossTable] = []
+    for model_factor in model.factors:
+        if (
+                EXCLUDE_UNNECESSARY_CROSS_TABLES
+                and len(model_factor.rvs) == 1
+                and model_factor.rvs[0] in model_rvs_with_children
+        ):
+            # The factor relates to a single random variable (has
+            # no parents) but it does have children.
+            # No need to include a cross-table as it is inferable from
+            # cross-tables of its children.
+            continue
+
+        rvs = tuple(pgm.rvs[model_rv.idx] for model_rv in model_factor.rvs)
+        cross_tables.append(cross_table_from_hard_dataset(dataset, rvs))
+        print('cross-table:', *rvs)
+
+    # Train the PGM
+    model_from_cross_tables(pgm, cross_tables)
+
+    # Show results
+    print()
+    pgm.dump(show_function_values=True)
+    print()
+    model_space = WMCProgram(DEFAULT_PGM_COMPILER(model))
+    pgm_space = WMCProgram(DEFAULT_PGM_COMPILER(pgm))
+    print('HI', divergence.hi(model_space, pgm_space))
+    print('KL', divergence.kl(model_space, pgm_space))
+
+
+if __name__ == '__main__':
+    main()

ck_demos/learning/demo_simple_learning.py

@@ -0,0 +1,55 @@
+from ck.dataset.dataset_from_csv import hard_dataset_from_csv
+from ck.learning.train_generative_bn import train_generative_bn
+from ck.pgm import PGM
+
+
+def main() -> None:
+    pgm = PGM('Student')
+
+    difficult = pgm.new_rv('difficult', ['y', 'n'])
+    intelligent = pgm.new_rv('intelligent', ['y', 'n'])
+    grade = pgm.new_rv('grade', ['low', 'medium', 'high'])
+    award = pgm.new_rv('award', ['y', 'n'])
+    letter = pgm.new_rv('letter', ['y', 'n'])
+
+    pgm.new_factor(difficult)
+    pgm.new_factor(intelligent)
+    pgm.new_factor(grade, intelligent, difficult)
+    pgm.new_factor(award, intelligent)
+    pgm.new_factor(letter, grade)
+
+    rvs = (difficult, intelligent, grade, award, letter)
+    csv = """
+    0,1,2,0,1
+    1,1,2,0,1
+    1,1,2,0,1
+    0,0,2,0,0
+    0,1,1,1,0
+    1,1,1,1,1
+    1,1,0,0,0
+    1,1,0,0,1
+    1,0,0,0,0
+    """
+
+    dataset = hard_dataset_from_csv(rvs, csv.splitlines())
+
+    # Learn parameters values for `pgm` using the training data `dataset`.
+    # This updates the PGMs potential functions.
+    train_generative_bn(pgm, dataset)
+
+    show_pgm_factors(pgm)
+
+    print('Done.')
+
+
+def show_pgm_factors(pgm: PGM) -> None:
+    for factor in pgm.factors:
+        potential_function = factor.function
+        print(f'Factor: {factor} {type(potential_function)}')
+        for instance, _, param_value in potential_function.keys_with_param:
+            print(f'Factor{instance} = {param_value}')
+        print()
+
+
+if __name__ == '__main__':
+    main()

ck_demos/sampling/demo_wmc_direct_sampler.py

@@ -2,7 +2,7 @@ import random
 
 from ck import example
 from ck.pgm import PGM
-from ck.pgm_compiler import factor_elimination
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
 from ck.pgm_circuit import PGMCircuit
 from ck.pgm_circuit.wmc_program import WMCProgram
 from ck.probability.empirical_probability_space import EmpiricalProbabilitySpace
@@ -18,7 +18,7 @@ def main():
 
     pgm: PGM = example.Rain()
 
-    pgm_cct: PGMCircuit = factor_elimination.compile_pgm(pgm)
+    pgm_cct: PGMCircuit = DEFAULT_PGM_COMPILER(pgm)
     wmc = WMCProgram(pgm_cct)
     sampler = wmc.sample_direct()
 

{compiled_knowledge-4.1.0a2.dist-info → compiled_knowledge-4.1.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.1.0a2
+Version: 4.1.0a3
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: llvmlite
 Requires-Dist: numpy
+Requires-Dist: scipy
 Dynamic: license-file
 
 Compiled Knowledge

{compiled_knowledge-4.1.0a2.dist-info → compiled_knowledge-4.1.0a3.dist-info}/RECORD

@@ -1,8 +1,8 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/pgm.py,sha256=DXI3RZWBlk6wNj9VlAEDGeEUQ1WIpQwojVAt231K-Co,121095
+ck/pgm.py,sha256=MaUPE1ymO9hX4Z-b780iX1w-5veU5VeMO5nFfvJ9e8U,121189
 ck/circuit/__init__.py,sha256=klUR7OVESf53-8Ho4f32clHFsR2SOz4XgwZzfDlms88,418
-ck/circuit/_circuit_cy.c,sha256=bEZxHMg02hky24K05HBdsLCHl8n-z6btIx5v-3q6nBE,1741715
-ck/circuit/_circuit_cy.cp312-win32.pyd,sha256=yVlwVrATq-xKGydrV8LO4Wg5IMCa9UMcLT0bZSX-tdM,221184
+ck/circuit/_circuit_cy.c,sha256=tNGfcT-8cwUIHwYGB4KOShUONM8ot0Hz-ixeqGPwKI0,1741715
+ck/circuit/_circuit_cy.cp312-win32.pyd,sha256=rXbBlHI73FEVMdMeENcP6KwD1z08em2hIT4Wk_RSDqo,221184
 ck/circuit/_circuit_cy.pxd,sha256=F1WU4KuX_knXQX-hwNKoHsoUK3fJLbLOxEnomWMJFpI,1057
 ck/circuit/_circuit_cy.pyx,sha256=TIjqsdyN_IzOm9XQw26kEURpL6GSL1kJO3K-UUlkbQc,27763
 ck/circuit/_circuit_py.py,sha256=gQZoEphxut2UyBL0ZqmNc8KlNBSMST_VOCqOpDMIRSM,28331
@@ -14,25 +14,24 @@ ck/circuit_compiler/llvm_compiler.py,sha256=6RHUCVWCOgt3ZNyjRTl2Z2npYJMWyAFJVAIc
 ck/circuit_compiler/llvm_vm_compiler.py,sha256=XJhiAZmGMRRz49XUfng9lgETxVw6NgD6XCI0H3fX-1E,22200
 ck/circuit_compiler/named_circuit_compilers.py,sha256=snlD3JnhAZC-atKpf5GD0v4CGdvj2_ZhCZ3O-tsxzxc,2284
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=GREvGu6-cceMpuIht7mHBloWicb2jvTy9d4wjbatX3g,871325
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win32.pyd,sha256=ATnbDBWk4dvHNeMzSdd-9r0frnKB3qb1txK1efC_QhI,91648
+ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=WypS3fPRAeal8e5qXrhr-yAlehCN7anOp31nxrZahyI,871325
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win32.pyd,sha256=QZSeYopWFzkBAGusscJq9Asr3Lu5zaUTCq-WFxt46GQ,91648
 ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=550r0AkOh8ZuuTRy3e6Aq-YqBQ82EKcap8e6f3zlEuM,13278
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=3Q-HCyA7VWFoXS9gn-k4LXedzqHPvdFNvWHfDcKYv6s,4473
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/circuit_compiler/support/input_vars.py,sha256=x6krN6sW9A-vZTteY4M4on_0vS4ChaaCcmnXcnQ4y0s,4812
 ck/circuit_compiler/support/llvm_ir_function.py,sha256=07IUmx4bGReDu-BsUhJEWM_onm8NmsHwQzJan1rnAFE,8572
 ck/circuit_compiler/support/circuit_analyser/__init__.py,sha256=RbyIObAAb-w0Ky4fB198xAfxTh2doquN9ez68SZSZgo,536
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=Z_i7EFoOaeztsOJK2iuUPJe6BVUGylcIXyn3WCxFBR0,448751
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win32.pyd,sha256=mPghEcc2-BqHKpoc4q0fOIUhn5Ai32gjxekY5IWztL4,47104
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=D5KZEt34naEQYjXupohXZrZtipaZf0TEdphHYsCGk4Q,448751
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win32.pyd,sha256=ICdyNrcTK1S25eQ6UyOWPn79jwmuyK-BO96F1RStKMs,47104
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.pyx,sha256=ctDOHOjnUhdsR_XHBrgchFVTImLhsEUjU3cqkP-GdF8,3331
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_py.py,sha256=eWjc2B946LeSzcGa9PyI4XQvlx_B1KPEiQuM6OOFjjQ,3086
 ck/dataset/__init__.py,sha256=3vxB-b8LdgtoZ73q28sdPYPUbCbXARH-fNGUZcxIzIo,56
-ck/dataset/cross_table.py,sha256=D8Y0WpISouAkMnt0j8bs4Csw_MhxT6h4eUucaQQOkmw,9745
-ck/dataset/cross_table_probabilities.py,sha256=U7LlmWUc_Ow6CVEk_6CLK0p2g8GlRpHEGPZFXrV8tmI,1997
-ck/dataset/dataset.py,sha256=fGxjEqv9qfdEq8s1ph8B_ptFftpf1wddVgYH8jDNtr0,22746
-ck/dataset/dataset_builder.py,sha256=e9fNbvDl1HhM49DxvvBtXWOHpvPPocBsTTzUsCpkR_A,18912
+ck/dataset/cross_table.py,sha256=j0HxWXJp14lOOJyb23T5LHEWziMYyY2UYnqIxdeG7kM,13348
+ck/dataset/dataset.py,sha256=yuX499Ue4V5T4YQJOEsslpGAoFZv-4UpTRk7zDVZ7B0,26213
+ck/dataset/dataset_builder.py,sha256=ZmDYz5xZrqbQLO4aLcESnBxmo838Z8CD0Y0-YrUNoio,19392
 ck/dataset/dataset_compute.py,sha256=B1BxTJ-JAsNk8l79iDRmJAQ5QwEvWgsI1wepRg4aQCQ,5845
-ck/dataset/dataset_from_crosstable.py,sha256=0I4jr4PtfBtniTFBHlAOlcl_ZH0NSD37azkcA2CaWSQ,1323
+ck/dataset/dataset_from_crosstable.py,sha256=bThBqyM4H0kfg4DonguLW1DIdkAQdlQa5nPAciMnMrI,2345
 ck/dataset/dataset_from_csv.py,sha256=Nn2RzZP_fhag2UaXzv27YEnKSo6oogKEVGEEafQuB6U,5953
 ck/dataset/sampled_dataset.py,sha256=8PfiTXqraSQ5rXpFUFFMN13jQL1x--_z9g6FYs2VW1U,3357
 ck/example/__init__.py,sha256=BXVxvTcl3tqgai-xJiGQIaG_ChlpPRdfWg985MQ7dwM,1744
@@ -77,15 +76,18 @@ ck/in_out/render_bugs.py,sha256=6YBhMIq3VRKFS0XqHbaWj6iz1io7O9icW23kukF_Cic,3383
 ck/in_out/render_net.py,sha256=LpQYAo_tF45vMIcHW1Ir5Zd_Ot69SPAK-e1Tl_6Ygo0,5147
 ck/in_out/render_pomegranate.py,sha256=gGvXyX9vOoilGIIL3rsMB07gERMU-12XPsttfSb4xLI,5764
 ck/learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/learning/train_generative.py,sha256=ho1RJPQQ_iq652rRnGoqVnZv4bZHVZshMAxcEsoW3h0,5700
+ck/learning/coalesce_cross_tables.py,sha256=lbEnddpiJ7tsUBBkhZD4kAVJnje-yNVUcGnxg6dgBJo,13321
+ck/learning/model_from_cross_tables.py,sha256=WOgC32zu7H1GA4DeHGeHSk3ehdp5r8iPh7onNQl0myE,9325
+ck/learning/parameters.py,sha256=PXLNq45zvlBqonMkQ1Lb-pYlHPnpI3osi2gabbpZMX0,4505
+ck/learning/train_generative_bn.py,sha256=wBk6xfU1EqvamFlMqScrsmmAVJIF0nFkAFiF3AegLJI,8217
 ck/pgm_circuit/__init__.py,sha256=B0CCjNMnPzrd0YiOEFdK4JzmRCvFIGJi3RJQ5Vg6fqA,37
-ck/pgm_circuit/marginals_program.py,sha256=DUvSND3ozQuBCZcmIsgwZ4w_IWCVV7O31Pm4PJ7ZDok,14786
+ck/pgm_circuit/marginals_program.py,sha256=ZrFDOvsv-Hn7G3rbuXJDtRxFdOpI_J9P7dvSkcBsnng,15139
 ck/pgm_circuit/mpe_program.py,sha256=-8fcb-txUiKo2bPKhApl_GD7U_gREC5SvU_D5sQe9sg,10226
 ck/pgm_circuit/pgm_circuit.py,sha256=DLjQmaVuAQ0YF6kCi15vDRiydLCJmufeo0hQJndqv2Y,3375
 ck/pgm_circuit/program_with_slotmap.py,sha256=5iIPVvhGncluMR-dfCIqXGjmzSnxLL-btfy80PI23DE,8025
 ck/pgm_circuit/slot_map.py,sha256=T4nBweoiivEdBDhYZ6GWpOXqSusRbp3vrSbCTyP1qpI,857
 ck/pgm_circuit/target_marginals_program.py,sha256=x4YQM-hUQRo2OLxodKJVOAKxqNlxmiDl9nGbbknypkY,3768
-ck/pgm_circuit/wmc_program.py,sha256=WtABU74FOCCJuKRCoDL4CyZ4CJXFmt9RSxiNNHsOhRY,12699
+ck/pgm_circuit/wmc_program.py,sha256=ZVGSyTh4pIP0BqITrHeibWmPNE1ntPp2hyR1bjBd9Tg,13052
 ck/pgm_circuit/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm_circuit/support/compile_circuit.py,sha256=5UtwaGQHWp8I5aVECXGQjkzKqXBRdO8dRunQNGSNdXo,3203
 ck/pgm_compiler/__init__.py,sha256=XCK1AWBBB9UYi6kbFnxMFzBL9a25EWfHnz_yn3ZKYuM,112
@@ -102,14 +104,16 @@ ck/pgm_compiler/support/factor_tables.py,sha256=tV9qE2zC8iwEQxTuXE6qiE6lmMpz4-Vc
 ck/pgm_compiler/support/join_tree.py,sha256=Chkyyo--ChgWEsDqTh8RCxPN7Z1NyvL--GjTC4ONvkY,12897
 ck/pgm_compiler/support/named_compiler_maker.py,sha256=g2MLnlkWXkISHL6dh23EY53SptTo7-itfuZogSpMdB8,1420
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=yJ05NvuNE9j0E_QnjDzHYfLqcHn5TdOleEpG3wSRgXQ,579
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=5TqAN98gLTZ3inQFBc_b6xpJJjjs2RJsbJ3loHHybho,730350
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win32.pyd,sha256=ORrARMf9nQD2dnrf95dV4nQYHZz_5JzW6kH5cIHGMOQ,87040
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=z7YUP7mDKX7wLq08O_rpphaj8C8s2dUAiWAtWRe1d4U,730350
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win32.pyd,sha256=jJPPoCruDzRvcZEoCHjxRVERAt-fE4eZf9vPYToj8Ek,87040
 ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=rVO1yxjZmZ6yv5s0zKq4Ji9WYrDuYTZsRG_zeF1_1xE,12015
 ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=h6xPYGBSy6XHQBFLPD2D1-V7Kiw9utY68nWrcGRMEg4,11287
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ck/probability/cross_table_probability_space.py,sha256=U7LlmWUc_Ow6CVEk_6CLK0p2g8GlRpHEGPZFXrV8tmI,1997
+ck/probability/divergence.py,sha256=v6aRxYGXN1pcUXh6HaAS6_h1eb01pD8D2fXbm4RXMEE,8484
 ck/probability/empirical_probability_space.py,sha256=sO31UIhePRFtkUDN84HT9qhtWsYa0vYaRdXMsttNgTk,2140
 ck/probability/pgm_probability_space.py,sha256=Slmp0mwDMoVh_86Y8L1QjAQsneazcK2VGQcRW8O2C3M,1267
-ck/probability/probability_space.py,sha256=RXNm2gIVcabjbr6WsNebZMKqL8LY32RRaRMGHE2cU6o,26109
+ck/probability/probability_space.py,sha256=C2ECA2_j4asaIstHL5pdSiDYfwdP30ShDn6pfAJi0Lk,26776
 ck/program/__init__.py,sha256=Ss9-0eqsGxCGloD6liH-0iqBG5Q3vPRF4XCw2hkDJ0M,110
 ck/program/program.py,sha256=gDJ5Q2kXZuaoHboa9yNTg0tQH9S-Gmw0BRx6PPV28pU,4184
 ck/program/program_buffer.py,sha256=1fiUcT7sqyr4vu8jXzK3ZsrgURFhWMdm6hr2BeS9ONA,5665
@@ -146,8 +150,12 @@ ck_demos/circuit_compiler/compare_circuit_compilers.py,sha256=IEzwvKt6c8wrmAyd6F
 ck_demos/circuit_compiler/show_llvm_program.py,sha256=HKUuyLfBjH6ZgD8l4gQWVSBPUh55ZCXjPa7ZEdm5OyU,712
 ck_demos/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/dataset/demo_dataset_builder.py,sha256=1OycYIr0C_3NCn0SLNoHftjStnRrGk_f0yNlckD6nh4,1024
+ck_demos/dataset/demo_dataset_from_sampler.py,sha256=7hd1vmnIv_q6qC9K6FSGiYm3vA6DSFapz6vItl1MHqQ,503
 ck_demos/getting_started/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/getting_started/simple_demo.py,sha256=AR40OtUVd-CJOxFlsu8_RtGLL2LLnZg506SzrIx7OQA,668
+ck_demos/learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ck_demos/learning/demo_bayesian_network_from_cross_tables.py,sha256=hnwj8k-4pDKDy16xk_q83S6LQUP6LveyZH9pGxXG97c,2650
+ck_demos/learning/demo_simple_learning.py,sha256=CtFdMKS8HmUWfr5CwXRkPtTI2HlL3Xw1jQdZcE7_j1s,1538
 ck_demos/pgm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/pgm/demo_pgm_dump.py,sha256=egcjSjMDJdyzxWGvHrgdF_g3CFYozLKv4XSXzvSfWbg,248
 ck_demos/pgm/demo_pgm_dump_stress.py,sha256=L9S3yp0EQM56kWztV4A6XzEqITOGbThImZIU0JofCDg,285
@@ -182,14 +190,14 @@ ck_demos/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 ck_demos/sampling/check_sampler.py,sha256=ZiXYS9CqGCX-Hd7zMKR_2TWZYTbbgF7TIqvYtq1Ofj0,2106
 ck_demos/sampling/demo_marginal_direct_sampler.py,sha256=RhNunuIUnYI_GXp9m8wzadMrgH9LYrr_Ohh1NApcFDk,1149
 ck_demos/sampling/demo_uniform_sampler.py,sha256=Z6tX_OYKGLc_w3-kEPK4KEZlJo7F5HOq_tUVppB_VQE,962
-ck_demos/sampling/demo_wmc_direct_sampler.py,sha256=c7maxTmZyIijaVdFs2h_KQbK30LvI-oCm2BXSUXVoD8,1113
+ck_demos/sampling/demo_wmc_direct_sampler.py,sha256=MC6I7kPhVxkdLU5ve31u59c-MjwDuSgHUXsjtRqQIqU,1105
 ck_demos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/utils/compare.py,sha256=Bwjpflevl4nusfA0zp96rInaVKFGuhC5Xv7HzA1Fobk,5088
 ck_demos/utils/convert_network.py,sha256=TSKj8q7L7J5rhrvwjaDkdYZ0Sg8vV5FRL_vCanX1CQw,1363
 ck_demos/utils/sample_model.py,sha256=in-Nlv-iuNIu6y9fDuMyo7nzgimBuTAnCWcpnVqvqDQ,8839
 ck_demos/utils/stop_watch.py,sha256=VzXHRWx0V8vPSD-bLgLlEYkCkR2FA0-KmM_pfKx-Pxo,13205
-compiled_knowledge-4.1.0a2.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.1.0a2.dist-info/METADATA,sha256=41mdCLKoTBDANacEu1V3Al9pup0b_6HjQ-DvBO4WUuk,1837
-compiled_knowledge-4.1.0a2.dist-info/WHEEL,sha256=LwxTQZ0gyDP_uaeNCLm-ZIktY9hv6x0e22Q-hgFd-po,97
-compiled_knowledge-4.1.0a2.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.1.0a2.dist-info/RECORD,,
+compiled_knowledge-4.1.0a3.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.1.0a3.dist-info/METADATA,sha256=9Rsb1P6zdDr5k2sWZQdLDvhQpmwzTCehDLM1dGimk3I,1859
+compiled_knowledge-4.1.0a3.dist-info/WHEEL,sha256=LwxTQZ0gyDP_uaeNCLm-ZIktY9hv6x0e22Q-hgFd-po,97
+compiled_knowledge-4.1.0a3.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.1.0a3.dist-info/RECORD,,

ck/learning/train_generative.py

@@ -1,149 +0,0 @@
-from dataclasses import dataclass
-from typing import Dict, Tuple, List
-
-import numpy as np
-
-from ck.dataset import SoftDataset, HardDataset
-from ck.dataset.cross_table import CrossTable, cross_table_from_dataset
-from ck.pgm import PGM, Instance, DensePotentialFunction, Shape, natural_key_idx, SparsePotentialFunction
-from ck.utils.iter_extras import multiply
-from ck.utils.np_extras import NDArrayFloat64
-
-
-@dataclass
-class ParameterValues:
-    """
-    A ParameterValues object represents learned parameter values of a PGM.
-    """
-    pgm: PGM
-    """
-    The PGM that the parameter values pertains to.
-    """
-
-    cpts: List[Dict[Instance, NDArrayFloat64]]
-    """
-    A list of CPTs co-indexed with `pgm.factors`. Each CPT is a dict
-    mapping from instances of the parent random variables (of the factors)
-    to the child conditional probability distribution (CPD).
-    """
-
-    def set_zero(self) -> None:
-        """
-        Set the potential function of each PGM factor to zero.
-        """
-        for factor in self.pgm.factors:
-            factor.set_zero()
-
-    def set_cpt(self) -> None:
-        """
-        Set the potential function of each PGM factor to a CPTPotentialFunction,
-        using our parameter values.
-        """
-        for factor, cpt in zip(self.pgm.factors, self.cpts):
-            factor.set_cpt().set(*cpt.items())
-
-    def set_dense(self) -> None:
-        """
-        Set the potential function of each PGM factor to a DensePotentialFunction,
-        using our parameter values.
-        """
-        for factor, cpt in zip(self.pgm.factors, self.cpts):
-            pot_function: DensePotentialFunction = factor.set_dense()
-            parent_shape: Shape = factor.shape[1:]
-            child_state: int
-            value: float
-            if len(parent_shape) == 0:
-                cpd: NDArrayFloat64 = cpt[()]
-                for child_state, value in enumerate(cpd):
-                    pot_function[child_state] = value
-            else:
-                parent_space: int = multiply(parent_shape)
-                parent_states: Instance
-                cpd: NDArrayFloat64
-                for parent_states, cpd in cpt.items():
-                    idx: int = natural_key_idx(parent_shape, parent_states)
-                    for value in cpd:
-                        pot_function[idx] = value
-                        idx += parent_space
-
-    def set_sparse(self) -> None:
-        """
-        Set the potential function of each PGM factor to a SparsePotentialFunction,
-        using our parameter values.
-        """
-        for factor, cpt in zip(self.pgm.factors, self.cpts):
-            pot_function: SparsePotentialFunction = factor.set_sparse()
-            parent_states: Instance
-            child_state: int
-            cpd: NDArrayFloat64
-            value: float
-            for parent_states, cpd in cpt.items():
-                for child_state, value in enumerate(cpd):
-                    key = (child_state,) + parent_states
-                    pot_function[key] = value
-
-
-def train_generative_bn(
-        pgm: PGM,
-        dataset: HardDataset | SoftDataset,
-        *,
-        dirichlet_prior: float = 0,
-        check_bayesian_network: bool = True,
-) -> ParameterValues:
-    """
-    Maximum-likelihood, generative training for a Bayesian network.
-
-    Args:
-        pgm: the probabilistic graphical model defining the model structure.
-            Potential function values are ignored and need not be set.
-        dataset: a dataset of random variable states.
-        dirichlet_prior: a real number >= 0. See `CrossTable` for an explanation.
-        check_bayesian_network: if true and not pgm.is_structure_bayesian an exception will be raised.
-
-    Returns:
-        a  ParameterValues object that can be used to update the parameters of the given PGM.
-
-    Raises:
-        ValueError: if the given PGM does not have a Bayesian network structure, and check_bayesian_network is True.
-    """
-    if check_bayesian_network and not pgm.is_structure_bayesian:
-        raise ValueError('the given PGM is not a Bayesian network')
-    cpts: List[Dict[Instance, NDArrayFloat64]] = [
-        cpt_from_crosstab(cross_table_from_dataset(dataset, factor.rvs, dirichlet_prior=dirichlet_prior))
-        for factor in pgm.factors
-    ]
-    return ParameterValues(pgm, cpts)
-
-
-def cpt_from_crosstab(crosstab: CrossTable) -> Dict[Instance, NDArrayFloat64]:
-    """
-    Make a conditional probability table (CPT) from a cross-table.
-
-    Args:
-        crosstab: a CrossTable representing the weight of unique instances.
-
-    Returns:
-        a mapping from instances of the parent random variables to the child
-        conditional probability distribution (CPD).
-
-    Assumes:
-        the first random variable in `crosstab.rvs` is the child random variable.
-    """
-    # Number of states for the child random variable.
-    child_size: int = len(crosstab.rvs[0])
-
-    # Get distribution over child states for seen parent states
-    parents_weights: Dict[Instance, NDArrayFloat64] = {}
-    for state, weight in crosstab.items():
-        parent_state: Tuple[int, ...] = state[1:]
-        child_state: int = state[0]
-        parent_weights = parents_weights.get(parent_state)
-        if parent_weights is None:
-            parents_weights[parent_state] = parent_weights = np.zeros(child_size, dtype=np.float64)
-        parent_weights[child_state] += weight
-
-    # Normalise
-    for parent_state, parent_weights in parents_weights.items():
-        parent_weights /= parent_weights.sum()
-
-    return parents_weights