compiled-knowledge 4.0.0a9__cp312-cp312-win_amd64.whl → 4.0.0a10__cp312-cp312-win_amd64.whl

ck/pgm.py

@@ -82,8 +82,8 @@ import math
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from itertools import repeat as _repeat
-from typing import Sequence, Tuple, Dict, Optional, overload, Iterator, Set, Iterable, List, Union, Callable, \
-    Collection, Any
+from typing import Sequence, Tuple, Dict, Optional, overload, Set, Iterable, List, Union, Callable, \
+    Collection, Any, Iterator
 
 import numpy as np
 
@@ -462,7 +462,7 @@ class PGM:
             a string representation of the given indicators.
         """
         return delim.join(
-            f'{rv}{sep}{state}'
+            f'{_clean_str(rv)}{sep}{_clean_str(state)}'
             for rv, state in (
                 self.indicator_pair(indicator)
                 for indicator in indicators
@@ -559,7 +559,7 @@ class PGM:
         assert len(instance) == len(rvs)
         return delim.join(str(rv.states[i]) for rv, i in zip(rvs, instance))
 
-    def instances(self, flip: bool = False) -> Iterator[Instance]:
+    def instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Iterate over all possible instances of this PGM, in natural index
         order (i.e., last random variable changing most quickly).
@@ -573,7 +573,7 @@ class PGM:
         """
         return _combos_ranges(tuple(len(rv) for rv in self._rvs), flip=not flip)
 
-    def instances_as_indicators(self, flip: bool = False) -> Iterator[Sequence[Indicator]]:
+    def instances_as_indicators(self, flip: bool = False) -> Iterable[Sequence[Indicator]]:
         """
         Iterate over all possible instances of this PGM, in natural index
         order (i.e., last random variable changing most quickly).
@@ -605,7 +605,7 @@ class PGM:
         """
         return tuple(rv[state] for rv, state in zip(self._rvs, instance))
 
-    def factor_values(self, key: Key) -> Iterator[float]:
+    def factor_values(self, key: Key) -> Iterable[float]:
         """
         For a given instance key, each factor defines a single value. This method
         returns those values.
@@ -717,6 +717,11 @@ class PGM:
         If no indicators are provided, then the value of the partition function (z)
         is returned.
 
+        If multiple indicators are provided for the same random variable, then all matching
+        instances are summed.
+
+        This method has the same semantics as `ProbabilitySpace.wmc` without conditioning.
+
         Warning:
             this is potentially computationally expensive as it marginalised random
             variables not mentioned in the given indicators.
@@ -727,29 +732,51 @@ class PGM:
         Returns:
             the product of factors, conditioned on the given instance. This is the
             computed value of the PGM, conditioned on the given instance.
-
-        Raises:
-            RuntimeError: if a random variable is referenced multiple times in the given indicators.
         """
-        # Create an instance from the indicators
-        inst: List[int] = [-1] * self.number_of_rvs
+        # # Create a filter from the indicators
+        # inst_filter: List[Set[int]] = [set() for _ in range(self.number_of_rvs)]
+        # for indicator in indicators:
+        #     rv_idx: int = indicator.rv_idx
+        #     inst_filter[rv_idx].add(indicator.state_idx)
+        # # Collect rvs not mentioned - to marginalise
+        # for rv, rv_filter in zip(self.rvs, inst_filter):
+        #     if len(rv_filter) == 0:
+        #         rv_filter.update(rv.state_range())
+        #
+        # def _sum_inst(_instance: Instance) -> bool:
+        #     return all(
+        #         (_state in _rv_filter)
+        #         for _state, _rv_filter in zip(_instance, inst_filter)
+        #     )
+        #
+        # # Accumulate the result
+        # sum_value = 0
+        # for instance in self.instances():
+        #     if _sum_inst(instance):
+        #         sum_value += self.value_product(instance)
+        #
+        # return sum_value
+
+        # Work out the space to sum over
+        sum_space_set: List[Optional[Set[int]]] = [None] * self.number_of_rvs
         for indicator in indicators:
             rv_idx: int = indicator.rv_idx
-            if inst[rv_idx] >= 0:
-                raise RuntimeError(f'random variable mentioned multiple times: {self.rvs[rv_idx]}')
-            inst[rv_idx] = indicator.state_idx
+            cur_set = sum_space_set[rv_idx]
+            if cur_set is None:
+                sum_space_set[rv_idx] = cur_set = set()
+            cur_set.add(indicator.state_idx)
 
-        # Collect rvs not mentioned - to marginalise
-        rvs = [rv for rv in self.rvs if inst[rv.idx] < 0]
+        # Convert to a list of states that we need to sum over.
+        sum_space_list: List[List[int]] = [
+            list(cur_set if cur_set is not None else rv.state_range())
+            for cur_set, rv in zip(sum_space_set, self.rvs)
+        ]
 
         # Accumulate the result
-        sum_value = 0
-        for instance in rv_instances_as_indicators(*rvs):
-            for indicator in instance:
-                inst[indicator.rv_idx] = indicator.state_idx
-            sum_value += self.value_product(inst)
-
-        return sum_value
+        return sum(
+            self.value_product(instance)
+            for instance in _combos(sum_space_list)
+        )
 
     def dump_synopsis(
             self,
@@ -937,8 +964,8 @@ class PGM:
         else:
             _cur_rv = sorted(cur_rv)
             rv = self._rvs[_cur_rv[0].rv_idx]
-            states_str = sep.join(str(rv.states[ind.state_idx]) for ind in _cur_rv)
-            cur_str += f'{rv}{elem}{{{states_str}}}'
+            states_str: str = sep.join(_clean_str(rv.states[ind.state_idx]) for ind in _cur_rv)
+            cur_str += f'{_clean_str(rv)}{elem}{{{states_str}}}'
         return cur_str
 
 
@@ -1095,7 +1122,7 @@ class RandomVariable(Sequence[Indicator]):
         """
         return range(len(self._states))
 
-    def factors(self) -> Iterator[Factor]:
+    def factors(self) -> Iterable[Factor]:
         """
         Iterate over factors that this random variable participates in.
         This method performs a search through all `self.pgm.factors`.
@@ -1194,8 +1221,8 @@ class RandomVariable(Sequence[Indicator]):
             return self.idx == other.idx and len(self) == len(other)
         else:
             return (
-                len(indicators) == len(other) and
-                all(indicators[i] == other[i] for i in range(len(indicators)))
+                    len(indicators) == len(other) and
+                    all(indicators[i] == other[i] for i in range(len(indicators)))
             )
 
     def __len__(self) -> int:
@@ -1467,7 +1494,7 @@ class Factor:
     def __getitem__(self, index):
         return self._rvs[index]
 
-    def instances(self, flip: bool = False) -> Iterator[Instance]:
+    def instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Iterate over all possible instances, in natural index order (i.e.,
         last random variable changing most quickly).
@@ -1481,7 +1508,7 @@ class Factor:
         """
         return self.function.instances(flip)
 
-    def parent_instances(self, flip: bool = False) -> Iterator[Instance]:
+    def parent_instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Iterate over all possible instances of parent random variable, in
         natural index order (i.e., last random variable changing most quickly).
@@ -1935,7 +1962,7 @@ class PotentialFunction(ABC):
             raise ValueError(f'invalid parameter index: {param_idx}')
         return ParamId(id(self), param_idx)
 
-    def items(self) -> Iterator[Tuple[Instance, float]]:
+    def items(self) -> Iterable[Tuple[Instance, float]]:
         """
         Iterate over all keys and values of this potential function.
 
@@ -1946,7 +1973,7 @@ class PotentialFunction(ABC):
         for key in _combos_ranges(self._shape, flip=True):
             yield key, self[key]
 
-    def instances(self, flip: bool = False) -> Iterator[Instance]:
+    def instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Iterate over all possible instances, in natural index order (i.e.,
         last random variable changing most quickly).
@@ -1960,7 +1987,7 @@ class PotentialFunction(ABC):
         """
         return _combos_ranges(self._shape, flip=not flip)
 
-    def parent_instances(self, flip: bool = False) -> Iterator[Instance]:
+    def parent_instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Iterate over all possible instances of parent random variable, in
         natural index order (i.e., last random variable changing most quickly).
@@ -2055,7 +2082,7 @@ class ZeroPotentialFunction(PotentialFunction):
         return self.number_of_states
 
     @property
-    def params(self) -> Iterator[Tuple[int, float]]:
+    def params(self) -> Iterable[Tuple[int, float]]:
         for param_idx in range(self.number_of_parameters):
             yield param_idx, 0
 
@@ -3047,7 +3074,7 @@ class CPTPotentialFunction(PotentialFunction):
         else:
             return self._values[offset:offset + child_size]
 
-    def cpds(self) -> Iterator[Tuple[Instance, Sequence[float]]]:
+    def cpds(self) -> Iterable[Tuple[Instance, Sequence[float]]]:
         """
         Iterate over (parent_states, cpd) tuples.
         This will exclude zero CPDs.
@@ -3358,7 +3385,7 @@ def number_of_states(*rvs: RandomVariable) -> int:
     return _multiply(len(rv) for rv in rvs)
 
 
-def rv_instances(*rvs: RandomVariable, flip: bool = False) -> Iterator[Instance]:
+def rv_instances(*rvs: RandomVariable, flip: bool = False) -> Iterable[Instance]:
     """
     Enumerate instances of the given random variables.
 
@@ -3377,7 +3404,7 @@ def rv_instances(*rvs: RandomVariable, flip: bool = False) -> Iterator[Instance]
     return _combos_ranges(shape, flip=not flip)
 
 
-def rv_instances_as_indicators(*rvs: RandomVariable, flip: bool = False) -> Iterator[Sequence[Indicator]]:
+def rv_instances_as_indicators(*rvs: RandomVariable, flip: bool = False) -> Iterable[Sequence[Indicator]]:
     """
     Enumerate instances of the given random variables.
 
@@ -3492,3 +3519,17 @@ def _normalise_potential_function(
             total = group_sum[group]
             if total > 0:
                 function.set_param_value(param_idx, param_value / total)
+
+
+_CLEAN_CHARS: Set[str] = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-+~?.')
+
+
+def _clean_str(s) -> str:
+    """
+    Quote a string if empty or not all characters are in _CLEAN_CHARS.
+    """
+    s = str(s)
+    if len(s) == 0 or not all(c in _CLEAN_CHARS for c in s):
+        return repr(s)
+    else:
+        return s

ck/pgm_circuit/pgm_circuit.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Sequence, List, Dict
 
-from ck.circuit import CircuitNode
+from ck.circuit import CircuitNode, Circuit
 from ck.pgm import RandomVariable, Indicator
 from ck.pgm_circuit.slot_map import SlotMap, SlotKey
 from ck.utils.np_extras import NDArray
@@ -46,19 +46,21 @@ class PGMCircuit:
 
     def dump(self, *, prefix: str = '', indent: str = '    ') -> None:
         """
-        Print a dump of the Join Tree.
+        Print a dump of the circuit.
         This is intended for debugging and demonstration purposes.
 
-        Each cluster is printed as: {separator rvs} | {non-separator rvs}.
-
         Args:
             prefix: optional prefix for indenting all lines.
             indent: additional prefix to use for extra indentation.
         """
-        # Name the circuit variables
-        circuit = self.circuit_top.circuit
+
+        # We infer names for the circuit variables, either as an indicator or as a parameter.
+        # The `var_names` will be passed to `circuit.dump`.
+
+        circuit: Circuit = self.circuit_top.circuit
         var_names: List[str] = [''] * circuit.number_of_vars
 
+        # Name the circuit variables that are indicators
         rvs_by_idx: Dict[int, RandomVariable] = {rv.idx: rv for rv in self.rvs}
         slot_key: SlotKey
         slot: int
@@ -68,8 +70,10 @@ class PGMCircuit:
                 state_idx = slot_key.state_idx
                 var_names[slot] = f'{rv.name!r}[{state_idx}] {rv.states[state_idx]!r}'
 
-        for slot, param_value in enumerate(self.parameter_values, start=self.number_of_indicators):
-            var_names[slot] = f'param {param_value}'
+        # Name the circuit variables that are parameters
+        for i, param_value in enumerate(self.parameter_values):
+            slot = i + self.number_of_indicators
+            var_names[slot] = f'param[{i}] = {param_value}'
 
-        # Show all the slots
+        # Dump the circuit
         circuit.dump(prefix=prefix, indent=indent, var_names=var_names)

ck/pgm_circuit/program_with_slotmap.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Iterator, Sequence, Dict, Iterable
+from typing import Tuple, Sequence, Dict, Iterable
 
 from ck.pgm import RandomVariable, rv_instances, Instance, rv_instances_as_indicators, Indicator, ParamId
 from ck.pgm_circuit.slot_map import SlotMap, SlotKey
@@ -30,11 +30,13 @@ class ProgramWithSlotmap:
                 has a length and rv[i] is a unique 'indicator' across all rvs.
             precondition: conditions on rvs that are compiled into the program.
 
+        Raises:
+            ValueError: if rvs contains duplicates.
         """
         self._program_buffer: ProgramBuffer = program_buffer
         self._slot_map: SlotMap = slot_map
         self._rvs: Tuple[RandomVariable, ...] = tuple(rvs)
-        self._precondition: Sequence[Indicator] = precondition
+        self._precondition: Tuple[Indicator, ...] = tuple(precondition)
 
         if len(rvs) != len(set(rv.idx for rv in rvs)):
             raise ValueError('duplicate random variables provided')
@@ -67,7 +69,7 @@ class ProgramWithSlotmap:
     def slot_map(self) -> SlotMap:
         return self._slot_map
 
-    def instances(self, flip: bool = False) -> Iterator[Instance]:
+    def instances(self, flip: bool = False) -> Iterable[Instance]:
         """
         Enumerate instances of the random variables.
 
@@ -84,7 +86,7 @@ class ProgramWithSlotmap:
         """
         return rv_instances(*self._rvs, flip=flip)
 
-    def instances_as_indicators(self, flip: bool = False) -> Iterator[Sequence[Indicator]]:
+    def instances_as_indicators(self, flip: bool = False) -> Iterable[Sequence[Indicator]]:
         """
         Enumerate instances of the random variables.
 

ck/pgm_compiler/ace/ace.py

@@ -5,7 +5,9 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, List, Tuple
 
-from ck.circuit import CircuitNode
+import numpy as np
+
+from ck.circuit import CircuitNode, Circuit
 from ck.in_out.parse_ace_lmap import read_lmap, LiteralMap
 from ck.in_out.parse_ace_nnf import read_nnf_with_literal_map
 from ck.in_out.render_net import render_bayesian_network
@@ -58,6 +60,22 @@ def compile_pgm(
     if check_is_bayesian_network and not pgm.check_is_bayesian_network():
         raise ValueError('the given PGM is not a Bayesian network')
 
+    # ACE cannot deal with the empty PGM even though it is a valid Bayesian network
+    if pgm.number_of_factors == 0:
+        circuit = Circuit()
+        circuit.new_vars(pgm.number_of_indicators)
+        parameter_values = np.array([], dtype=np.float64)
+        slot_map = {indicator: i for i, indicator in enumerate(pgm.indicators)}
+        return PGMCircuit(
+            rvs=pgm.rvs,
+            conditions=(),
+            circuit_top=circuit.const(1),
+            number_of_indicators=pgm.number_of_indicators,
+            number_of_parameters=0,
+            slot_map=slot_map,
+            parameter_values=parameter_values,
+        )
+
     java: str
     classpath_separator: str
     java, classpath_separator = _find_java()
@@ -69,7 +87,7 @@ def compile_pgm(
     )
     ace_cmd: List[str] = [
         java,
-        f'-cp',
+        '-cp',
         class_path,
         f'-DACEC2D={files.c2d}',
         f'-Xmx{int(m_bytes)}m',
@@ -83,7 +101,7 @@ def compile_pgm(
             node_names: List[str] = render_bayesian_network(pgm, file, check_structure_bayesian=False)
 
         # Run Ace
-        ace_result = subprocess.run(ace_cmd, capture_output=True, text=True)
+        ace_result: subprocess.CompletedProcess = subprocess.run(ace_cmd, capture_output=True, text=True)
         if print_output:
             print(ace_result.stdout)
             print(ace_result.stderr)
@@ -126,6 +144,29 @@ def compile_pgm(
     )
 
 
+def ace_available(
+        ace_dir: Optional[Path | str] = None,
+        jar_dir: Optional[Path | str] = None,
+) -> bool:
+    """
+    Returns:
+        True if it looks like ACE is available, False otherwise.
+        ACE is available if ACE files are in the default location and Java is available.
+    """
+    try:
+        java: str
+        java, _ = _find_java()
+        _: _AceFiles = _find_ace_files(ace_dir, jar_dir)
+
+        java_cmd: List[str] = [java, '--version',]
+        java_result: subprocess.CompletedProcess = subprocess.run(java_cmd, capture_output=True, text=True)
+
+        return java_result.returncode == 0
+
+    except RuntimeError:
+        return False
+
+
 def copy_ace_to_default_location(
         ace_dir: Path | str,
         jar_dir: Optional[Path | str] = None,
@@ -179,6 +220,9 @@ def _find_java() -> Tuple[str, str]:
 
     Returns:
         (java, classpath_separator)
+
+    Raises:
+        RuntimeError: if not found, including a helpful message.
     """
     if sys.platform == 'win32':
         return 'java.exe', ';'
@@ -198,7 +242,7 @@ def _find_ace_files(
     Look for the needed Ace files.
 
     Raises:
-        RuntimeError: if not found, including a helpful message .
+        RuntimeError: if not found, including a helpful message.
     """
     ace_dir: Path = default_ace_location() if ace_dir is None else Path(ace_dir)
     jar_dir: Path = ace_dir if jar_dir is None else Path(jar_dir)

ck/pgm_compiler/factor_elimination.py

@@ -12,19 +12,21 @@ from ck.pgm_compiler.support.join_tree import *
 
 _NEG_INF = float('-inf')
 
+DEFAULT_PRODUCT_SEARCH_LIMIT: int = 1000
+
 
 def compile_pgm(
         pgm: PGM,
         const_parameters: bool = True,
         *,
         algorithm: JoinTreeAlgorithm = MIN_FILL_THEN_DEGREE,
-        limit_product_tree_search: int = 1000,
+        limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
         pre_prune_factor_tables: bool = True,
 ) -> PGMCircuit:
     """
     Compile the PGM to an arithmetic circuit, using factor elimination.
 
-    When forming the product of factors withing a join tree nodes,
+    When forming the product of factors within join tree nodes,
     this method searches all practical binary trees for forming products,
     up to the given limit, `limit_product_tree_search`. The minimum is 1.
 
@@ -57,7 +59,7 @@ def compile_pgm_best_jointree(
         pgm: PGM,
         const_parameters: bool = True,
         *,
-        limit_product_tree_search: int = 1000,
+        limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
         pre_prune_factor_tables: bool = True,
 ) -> PGMCircuit:
     """
@@ -111,7 +113,7 @@ def compile_pgm_best_jointree(
 def join_tree_to_circuit(
         join_tree: JoinTree,
         const_parameters: bool = True,
-        limit_product_tree_search: int = 1000,
+        limit_product_tree_search: int = DEFAULT_PRODUCT_SEARCH_LIMIT,
         pre_prune_factor_tables: bool = True,
 ) -> PGMCircuit:
     """

ck/pgm_compiler/recursive_conditioning.py

@@ -52,10 +52,15 @@ def compile_pgm(
         multiply_indicators=True,
         pre_prune_factor_tables=pre_prune_factor_tables,
     )
-    dtree: _DTree = _make_dtree(elimination_order, factor_tables)
 
-    states: List[Sequence[int]] = [tuple(range(len(rv))) for rv in pgm.rvs]
-    top: CircuitNode = dtree.make_circuit(states, factor_tables.circuit)
+    if pgm.number_of_factors == 0:
+        # Deal with special case: no factors
+        top: CircuitNode = factor_tables.circuit.const(1)
+    else:
+        dtree: _DTree = _make_dtree(elimination_order, factor_tables)
+        states: List[Sequence[int]] = [tuple(range(len(rv))) for rv in pgm.rvs]
+        top: CircuitNode = dtree.make_circuit(states, factor_tables.circuit)
+
     top.circuit.remove_unreachable_op_nodes(top)
 
     return PGMCircuit(