compiled-knowledge 4.1.0a3__tar.gz → 4.2.0a1__tar.gz

{compiled_knowledge-4.1.0a3/src/compiled_knowledge.egg-info → compiled_knowledge-4.2.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.1.0a3
+Version: 4.2.0a1
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "compiled-knowledge"
-version = "4.1.0a3"
+version = "4.2.0a1"
 description = "A Python package for compiling and querying discrete probabilistic graphical models."
 readme = "README.md"
 license = "MIT"
@@ -20,8 +20,7 @@ classifiers = [
 ]
 
 [doc_extra]
-version_note = "A pre-release version of 4.1.0 that includes dataset and machine learning functionality for community feedback."
-
+version_note = "A pre-release version of 4.2.0 that includes enhancements for `synthorus`."
 
 [project.urls]
 Homepage = "https://github.com/ropeless/compiled_knowledge"

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/setup.py

@@ -3,6 +3,7 @@
 # Usage:
 #    python setup.py build_ext --inplace
 #    python setup.py sdist bdist_wheel
+#
 import sys
 from pathlib import Path
 from typing import List, Tuple

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/ck/circuit_compiler/llvm_compiler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, auto
 from typing import Sequence, Optional, Tuple, Dict, Protocol, assert_never
 
 import llvmlite.binding as llvm
@@ -15,9 +15,9 @@ from ..program.raw_program import RawProgramFunction
 
 
 class Flavour(Enum):
-    STACK = 0  # No working temporary memory requested - all on stack.
-    TMPS = 1  # Working temporary memory used for op node calculations.
-    FUNCS = 2  # Working temporary memory used for op node calculations, one sub-function per op-node.
+    STACK = auto()  # No working temporary memory requested - all on stack.
+    TMPS = auto()  # Working temporary memory used for op node calculations.
+    FUNCS = auto()  # Working temporary memory used for op node calculations, one sub-function per op-node.
 
 
 DEFAULT_TYPE_INFO: TypeInfo = DataType.FLOAT_64.value

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/ck/circuit_compiler/support/input_vars.py

@@ -3,7 +3,7 @@ This module supports circuit compilers and interpreters by inferring and checkin
 that are explicitly or implicitly referred to by a client.
 """
 
-from enum import Enum
+from enum import Enum, auto
 from itertools import chain
 from typing import Sequence, Optional, Set, Iterable, List
 
@@ -15,9 +15,9 @@ class InferVars(Enum):
     An enum specifying how to automatically infer a program's input variables.
     """
 
-    ALL = 'all'  # all circuit vars are input vars
-    REF = 'ref'  # only referenced vars are input vars
-    LOW = 'low'  # input vars are circuit vars[0 : max_referenced + 1]
+    ALL = auto()  # all circuit vars are input vars
+    REF = auto()  # only referenced vars are input vars
+    LOW = auto()  # input vars are circuit vars[0 : max_referenced + 1]
 
 
 # Type for specifying input circuit vars

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/ck/learning/coalesce_cross_tables.py

@@ -22,10 +22,18 @@ def coalesce_cross_tables(crosstabs: Sequence[CrossTable], rvs: Sequence[RandomV
 
     `a` is a column vector with one entry for each instance of rvs seen in the cross-tables.
 
-    `b` is a column vector containing all probabilities from all cross-tables (normalised weights).
+    `b` is a column vector containing all probabilities from all cross-tables.
 
     `m` is a sparse matrix with m[i, j] = 1 where b[j] is in the sum for source probability a[i].
 
+    "Best" means the vector `a` with:
+    * `a[i] >= 0` for all i, then
+    * `b - m a` having the smallest L2 norm, then
+    * `a` having the smallest L2 norm.
+
+    The given crosstables will be used to form `b`. The entries each cross-table will be normalised
+    to represent a probability distribution over the cross-table's instances (keys).
+
     Args:
         crosstabs: a collection of cross-tables to coalesce.
         rvs: the random variables that cross-tables will be projected on to.
@@ -171,8 +179,8 @@ def _make_matrix(
     Returns:
         the tuple (m, b, a_keys) where
         'm' is a sparse matrix,
-        'b' is a numpy array of crosstab probabilities,
-        'a_keys' are the keys for the solution probabilities.
+        'b' is a numpy array of crosstab probabilities (normalised as needed),
+        'a_keys' are the keys for the solution probabilities, co-indexed with `a`.
     """
 
     # Sum out any unneeded random variables

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/ck/learning/model_from_cross_tables.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from enum import Enum, auto
 from itertools import chain
 from typing import Iterable, List, Tuple, Dict, Sequence, Set, Optional
 
@@ -12,7 +13,37 @@ from ck.pgm import PGM, RandomVariable
 from ck.utils.map_list import MapList
 
 
-def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> None:
+class ParameterInference(Enum):
+    """
+    There are variations on the method for inferring a CPT's parameter values.
+    This enum defines the possible variations.
+    """
+    first = auto()
+    """
+    Use the first cross-table found that covers the CPT's random variables.
+    If there is no such cross-table, revert to the `all` method.
+    This is the fastest method.
+    """
+
+    sum = auto()
+    """
+    Use the sum of cross-tables that cover the CPT's random variables.
+    If there are no such cross-tables, revert to the `all` method.
+    This is the second fastest method.
+    """
+
+    all = auto()
+    """
+    Project all cross-tables onto the needed random variables, then use
+    `coalesce_cross_tables` to solve for the best parameter values.
+    """
+
+
+def model_from_cross_tables(
+        pgm: PGM,
+        cross_tables: Iterable[CrossTable],
+        method: ParameterInference = ParameterInference.sum,
+) -> None:
     """
     Make best efforts to construct a Bayesian network model given only the
     evidence from the supplied cross-tables.
@@ -24,6 +55,7 @@ def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> Non
     Args:
         pgm: the PGM to add factors and potential function to.
         cross_tables: available cross-tables to build a model from.
+        method: what parameter inference method to use.
 
     Raises:
         ValueError: If `pgm` has any existing factors.
@@ -33,11 +65,16 @@ def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> Non
     cpts: List[CrossTable] = get_cpts(
         rvs=pgm.rvs,
         cross_tables=cross_tables,
+        method=method,
     )
     make_factors(pgm, cpts)
 
 
-def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable]) -> ParameterValues:
+def get_cpts(
+        rvs: Sequence[RandomVariable],
+        cross_tables: Iterable[CrossTable],
+        method: ParameterInference = ParameterInference.sum,
+) -> ParameterValues:
     """
     Make best efforts to define a Bayesian network model given only the
     evidence from the supplied cross-tables.
@@ -53,6 +90,7 @@ def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable])
     Args:
         rvs: the random variables to define a network structure over.
         cross_tables: available cross-tables to build a model from.
+        method: what parameter inference method to use.
 
     Returns:
         ParameterValues object as a list of CPTs, each CPT can be used to create
@@ -90,13 +128,17 @@ def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable])
     # Make the factors, depth first.
     done: Set[int] = set()
     for model_factor in model_factors:
-        _infer_cpt(model_factor, done)
+        _infer_cpt(model_factor, done, method)
 
     # Return the CPTs that define the structure
     return [model_factor.cpt for model_factor in model_factors]
 
 
-def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
+def _infer_cpt(
+        model_factor: _ModelFactor,
+        done: Set[int],
+        method: ParameterInference,
+) -> None:
     """
     Depth-first recursively infer the model factors as CPTs.
     This sets `model_factor.cpt` and `model_factor.parent_rvs` for
@@ -110,7 +152,7 @@ def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
 
     # Recursively visit the child factors
     for child_model_factor in model_factor.child_factors:
-        _infer_cpt(child_model_factor, done)
+        _infer_cpt(child_model_factor, done, method)
 
     # Get all relevant cross-tables to set the parameters
     crosstabs: Sequence[CrossTable] = model_factor.cross_tables
@@ -121,19 +163,20 @@ def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
 
     # Get the parameters
     rvs = [child_rv] + list(model_factor.parent_rvs)
-    crosstab: CrossTable = _infer_parameters(rvs, crosstabs, child_crosstabs)
+    crosstab: CrossTable = _infer_parameter_values(rvs, crosstabs, child_crosstabs, method)
     cpt, parent_sums = cpt_and_parent_sums_from_crosstab(crosstab)
     model_factor.cpt = cpt
     model_factor.parent_sums = parent_sums
 
 
-def _infer_parameters(
+def _infer_parameter_values(
         rvs: Sequence[RandomVariable],
         crosstabs: Sequence[CrossTable],
         child_crosstabs: Sequence[CrossTable],
+        method: ParameterInference,
 ) -> CrossTable:
     """
-    Make best efforts to infer a probability distribution over the give random variables,
+    Make best efforts to infer a probability distribution over the given random variables,
     with evidence from the given cross-tables.
 
     Returns:
@@ -144,8 +187,16 @@ def _infer_parameters(
         `rvs` has no duplicates.
     """
 
+    if method == ParameterInference.all:
+        # Forced to use all cross-tables with `coalesce_cross_tables`
+        projected_crosstabs: List[CrossTable] = [
+            crosstab.project(rvs)
+            for crosstab in chain(crosstabs, child_crosstabs)
+        ]
+        return coalesce_cross_tables(projected_crosstabs, rvs)
+
     # Project crosstables onto rvs, splitting them into complete and partial coverage of `rvs`.
-    # Completely covering cross-tables will be accumulated into `complete_crosstab` while others
+    # Completely covering cross-tables will be summed into `complete_crosstab` while others
     # will be appended to partial_crosstabs.
     complete_crosstab: Optional[CrossTable] = None
     partial_crosstabs: List[CrossTable] = []
@@ -153,10 +204,13 @@ def _infer_parameters(
         available_rvs: Set[RandomVariable] = set(available_crosstab.rvs)
         if available_rvs.issuperset(rvs):
             to_add: CrossTable = available_crosstab.project(rvs)
+            if method == ParameterInference.first:
+                # Take the first available solution.
+                return to_add
             if complete_crosstab is None:
                 complete_crosstab = to_add
             else:
-                complete_crosstab.add_all(to_add.project(rvs).items())
+                complete_crosstab.add_all(to_add.items())
         else:
             partial_crosstabs.append(available_crosstab)
 

compiled_knowledge-4.2.0a1/src/ck/utils/map_dict.py

@@ -0,0 +1,89 @@
+"""
+This module defines a class "MapDict" for mapping keys to dicts.
+"""
+
+from typing import TypeVar, Generic, Dict, MutableMapping, Iterator, KeysView, ValuesView, ItemsView
+
+_K = TypeVar('_K')
+_KV = TypeVar('_KV')
+_V = TypeVar('_V')
+
+
+class MapDict(Generic[_K, _KV, _V], MutableMapping[_K, Dict[_KV, _V]]):
+    """
+    A MapDict keeps a dict for each key.
+    """
+    __slots__ = ('_map',)
+
+    def __init__(self):
+        self._map: Dict[_K, Dict[_KV, _V]] = {}
+
+    def __str__(self) -> str:
+        return str(self._map)
+
+    def __repr__(self) -> str:
+        args = ', '.join(f'{key!r}:{key!r}' for key, val in self.items())
+        class_name = self.__class__.__name__
+        return f'{class_name}({args})'
+
+    def __len__(self) -> int:
+        return len(self._map)
+
+    def __bool__(self) -> bool:
+        return len(self) > 0
+
+    def __getitem__(self, key: _K) -> Dict[_KV, _V]:
+        return self._map[key]
+
+    def __setitem__(self, key: _K, val: Dict[_KV, _V]):
+        if not isinstance(val, dict):
+            class_name = self.__class__.__name__
+            raise RuntimeError(f'every {class_name} value must be a dict')
+        self._map[key] = val
+
+    def __delitem__(self, key: _K):
+        del self._map[key]
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._map)
+
+    def __contains__(self, key: _K) -> bool:
+        return key in self._map
+
+    def keys(self) -> KeysView[_K]:
+        return self._map.keys()
+
+    def values(self) -> ValuesView[Dict[_KV, _V]]:
+        return self._map.values()
+
+    def items(self) -> ItemsView[_K, Dict[_KV, _V]]:
+        return self._map.items()
+
+    def get(self, key: _K, default=None):
+        """
+        Get the list corresponding to the given key.
+        If the key is not yet in the MapList then the
+        supplied default will be returned.
+        """
+        return self._map.get(key, default)
+
+    def get_dict(self, key: _K) -> Dict[_KV, _V]:
+        """
+        Get the dict corresponding to the given key.
+
+        This method will always return a dict in the MapDict, even if
+        it requires a new dict being created.
+
+        Modifying the returned dict affects this MapDict object.
+        """
+        the_dict = self._map.get(key)
+        if the_dict is None:
+            the_dict = {}
+            self._map[key] = the_dict
+        return the_dict
+
+    def clear(self):
+        """
+        Remove all items.
+        """
+        return self._map.clear()

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/ck_demos/learning/demo_bayesian_network_from_cross_tables.py

@@ -14,11 +14,10 @@ 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
+    number_of_samples: int = 10000  # How many instances to make for the model dataset
     model: PGM = example.Student()
-    model_dataset = dataset_from_sampler(
+    model_dataset: HardDataset = dataset_from_sampler(
         WMCProgram(DEFAULT_PGM_COMPILER(model)).sample_direct(),
         number_of_samples,
     )

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1/src/compiled_knowledge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.1.0a3
+Version: 4.2.0a1
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT

{compiled_knowledge-4.1.0a3 → compiled_knowledge-4.2.0a1}/src/compiled_knowledge.egg-info/SOURCES.txt

@@ -132,6 +132,7 @@ src/ck/sampling/wmc_rejection_sampler.py
 src/ck/utils/__init__.py
 src/ck/utils/iter_extras.py
 src/ck/utils/local_config.py
+src/ck/utils/map_dict.py
 src/ck/utils/map_list.py
 src/ck/utils/map_set.py
 src/ck/utils/np_extras.py