compiled-knowledge 4.0.0a5__cp313-cp313-macosx_10_13_universal2.whl

ck_demos/utils/convert_network.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+from ck.in_out.parse_net import read_network
+from ck.in_out.pgm_python import write_python
+from ck.pgm import PGM
+
+
+def convert_network(network_path: Path, file=None) -> None:
+    """
+    Convert a Hugin 'net' format to our PGM format.
+
+    Args:
+        network_path: path to a Hugin 'net' file.
+        file: destination, as per the `print` function.
+    """
+    # Read the Hugin 'net' file.
+    with open(network_path) as in_file:
+        pgm: PGM = read_network(in_file)
+
+    # Replace functions that may be better being sparse
+    for factor in pgm.factors:
+        function = factor.function
+        total_params: int = function.number_of_parameters
+        zero_params: int = sum(1 for _, value in function.params if value == 0)
+        if zero_params > 10 and zero_params / total_params > 0.1:
+            new_function = factor.set_sparse()
+            for key, _, value in function.keys_with_param:
+                new_function[key] = value
+
+    # Write the PGM Python code.
+    write_python(pgm, file=file)
+
+
+def main() -> None:
+    """
+    Demo of `convert_network`.
+    """
+    network_directory = r'E:\Dropbox\Research\data\BN\networks'
+    network_name = 'pathfinder'
+
+    convert_network(Path(network_directory) / f'{network_name}.net')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/utils/sample_model.py

@@ -0,0 +1,216 @@
+import random
+from typing import Optional, Dict, Callable, List
+
+import numpy as np
+
+from ck.pgm import rv_instances, PGM, RandomVariable, Indicator
+from ck.pgm_compiler import factor_elimination
+from ck.pgm_circuit.marginals_program import MarginalsProgram
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.sampling.forward_sampler import ForwardSampler
+from ck.sampling.sampler import Sampler
+from ck.utils.random_extras import random_permute
+from ck_demos.utils.stop_watch import StopWatch
+
+SamplerFactory = Callable[[PGM, WMCProgram, MarginalsProgram, List[RandomVariable], List[Indicator]], Sampler]
+
+BURN_IN: int = 1000  # Burn in for standard samplers, where needed. Not all samplers use burn in.
+
+# Standard Samplers (by name)
+STANDARD_SAMPLERS: Dict[str, SamplerFactory] = {
+    'Direct-wmc': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        wmc.sample_direct(rvs=sample_rvs, condition=condition)
+    ),
+    'Direct-mar': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        mar.sample_direct(rvs=sample_rvs, condition=condition)
+    ),
+    'Rejection': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        wmc.sample_rejection(rvs=sample_rvs, condition=condition)
+    ),
+    'Gibbs': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        wmc.sample_gibbs(burn_in=BURN_IN, rvs=sample_rvs, condition=condition)
+    ),
+    'Metropolis': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        wmc.sample_metropolis(burn_in=BURN_IN, rvs=sample_rvs, condition=condition)
+    ),
+    'Forward': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        ForwardSampler(pgm, sample_rvs, condition, check_is_bayesian_network=True)
+    ),
+    'Uniform': (
+        lambda pgm, wmc, mar, sample_rvs, condition:
+        wmc.sample_uniform(rvs=sample_rvs, condition=condition)
+    ),
+}
+
+
+def sample_model(
+        pgm: PGM,
+        samplers: Dict[str, SamplerFactory],
+        num_of_trials: int,
+        num_of_samples: int,
+        limit_conditioning: Optional[int] = None,
+        show_each_analysis: bool = True,
+        line: str = '-' * 80,
+):
+    """
+    Evaluate the given samplers on the given PGM.
+
+    Results are printed to standard out.
+
+    Args:
+        pgm: is the model to sample.
+        samplers: is a dict from sampler name to factory method. The
+            factor method type is (pgm, wmc, mar, sample_rvs, condition) -> Sampler.
+        num_of_trials: how many trials to perform.
+        num_of_samples: how many num_of_samples to draw from each sampler, for each trial.
+        limit_conditioning: maximum number of indicators to use when determining
+            conditioning for a trial, or None then pgm.number_of_random_variables is used.
+        show_each_analysis: if True, then extra details is printed.
+        line: is the 'line' string to use to delimit trials.
+    """
+    print(f'Model:                      {pgm.name}')
+    print(f'Number of random variables: {pgm.number_of_rvs}')
+    print(f'Number of indicators:       {pgm.number_of_indicators}')
+    print(f'States space:               {pgm.number_of_states:,}')
+
+    # compile
+    pgm_cct: PGMCircuit = factor_elimination.compile_pgm(pgm)
+    wmc = WMCProgram(pgm_cct)
+    mar = MarginalsProgram(pgm_cct)
+
+    rvs = pgm.rvs
+    num_of_rvs = len(rvs)
+    sampler_names = list(samplers.keys())
+    overall_max_difference = {name: 0 for name in sampler_names}
+    overall_sum_difference = {name: 0 for name in sampler_names}
+    overall_time = {name: 0 for name in sampler_names}
+    errors = {name: [] for name in sampler_names}
+
+    name_pad = max(
+        max(len(name) for name in sampler_names) + 1,
+        max(len(rv.name) for rv in rvs) + 1
+    )
+
+    for trial in range(1, 1 + num_of_trials):
+        print(line)
+
+        # what random variables to sample
+        num_rvs_to_sample = random.randint(1, num_of_rvs)
+        sample_rvs = list(rvs)
+        random_permute(sample_rvs)
+        del sample_rvs[num_rvs_to_sample:]
+        sample_rvs.sort(key=(lambda rv: rv.idx))
+        rvs_str = ', '.join([str(rv) for rv in sample_rvs])
+
+        # what conditions
+        if limit_conditioning is None:
+            limit_conditioning = pgm.number_of_rvs
+        if limit_conditioning == 0:
+            condition = ()
+            condition_str = ''
+        else:
+            while True:
+                num_indicators_to_condition = random.randint(0, limit_conditioning)
+                rand_rvs = list(rvs)
+                random_permute(rand_rvs)
+                condition = []
+                while len(condition) < num_indicators_to_condition and len(rand_rvs) > 0:
+                    rv = rand_rvs.pop()
+                    max_rv_indicators_to_condition = min(len(rv) - 1, num_indicators_to_condition - len(condition))
+                    assert max_rv_indicators_to_condition >= 1, 'assumption check'
+                    num_rv_indicators_to_condition = random.randint(1, max_rv_indicators_to_condition)
+                    indicators = list(rv)
+                    random_permute(indicators)
+                    condition += sorted(indicators[:num_rv_indicators_to_condition])
+
+                if len(condition) == 0:
+                    condition_str = ''
+                    break
+
+                condition_str = ' | ' + pgm.condition_str(*condition)
+
+                # only accept the condition if the Pr(condition) > 0
+                if wmc.probability(*condition) > 0:
+                    break
+                print(f'Note: discarded impossible condition{condition_str}')
+
+        # show the trial parameters
+        print(f'trial {trial} of {num_of_trials}: {rvs_str}{condition_str}')
+
+        # create state indexes for printing
+        state_to_index = {}
+        all_states = []
+        for i, state in enumerate(rv_instances(*sample_rvs)):
+            state = tuple(state)
+            all_states.append(state)
+            state_to_index[state] = i
+
+        # print detailed results - header
+        for i, rv in enumerate(sample_rvs):
+            print(str(rv).ljust(name_pad), end='')
+            print(' '.join([f'{str(state[i]).ljust(7)}' for state in all_states]))
+
+        # pgm_stats
+        print('PGM'.ljust(name_pad), end='')
+        pgm_stats = np.array(wmc.marginal_distribution(*sample_rvs, condition=condition))
+        print(' '.join([f'{p:.5f}' for p in pgm_stats]))
+
+        for sampler_name in sampler_names:
+            print(sampler_name.ljust(name_pad), end='')
+
+            # sample_stats
+            try:
+                sample_stats = np.zeros(len(all_states))
+                sampler = samplers[sampler_name](pgm, wmc, mar, sample_rvs, condition)
+                stop_watch = StopWatch()
+                for state in sampler.take(num_of_samples):
+                    i = state_to_index[tuple(state)]
+                    sample_stats[i] += 1
+                stop_watch.stop()
+                sample_stats /= np.sum(sample_stats)
+            except (ValueError, RuntimeError, AssertionError) as err:
+                errors[sampler_name].append(repr(err))
+                print(repr(err))
+                continue
+
+            # print detailed results - for this sampler
+            print(' '.join([f'{p:.5f}' for p in sample_stats]))
+
+            # analyse
+            max_difference = 0
+            sum_difference = 0
+            for pgm_stat, sample_stat in zip(pgm_stats, sample_stats):
+                diff = abs(pgm_stat - sample_stat)
+                max_difference = max(max_difference, diff)
+                sum_difference += diff
+            overall_max_difference[sampler_name] = max(overall_max_difference[sampler_name], max_difference)
+            overall_sum_difference[sampler_name] = max(overall_sum_difference[sampler_name], sum_difference)
+            overall_time[sampler_name] += stop_watch.seconds()
+
+            if show_each_analysis:
+                print(
+                    ' ' * name_pad +
+                    f'max_difference = {max_difference}, '
+                    f'sum_difference = {sum_difference}, '
+                    f'time = {stop_watch.seconds()}'
+                )
+
+    print(line)
+    sep: str = ', '
+    print(' ' * name_pad + sep.join(['overall_max_difference', 'overall_sum_difference', 'overall_time', 'errors']))
+    for sampler_name in sampler_names:
+        print(
+            f'{sampler_name.ljust(name_pad)}'
+            f'{overall_max_difference[sampler_name]}{sep}'
+            f'{overall_sum_difference[sampler_name]}{sep}'
+            f'{overall_time[sampler_name]}{sep}'
+            f'{len(errors[sampler_name])}'
+        )
+    print()

ck_demos/utils/stop_watch.py

@@ -0,0 +1,384 @@
+"""
+A simple code execution timer.
+
+Example usage:
+```
+    time = StopWatch()
+    # Do some work
+    time.stop()
+
+    print('time:', time)
+```
+Alternate usage:
+```
+    with timer('stuff'):
+        # do some stuff
+```
+Usage of ProgressCheck:
+```
+    check = ProgressCheck(60)
+    for iteration in range(max_iterations):
+        # Do one iteration.
+        ...
+
+        if check:
+            print(f'progress: {iteration=} time={check}')
+```
+"""
+from __future__ import annotations
+
+import timeit as _timeit
+from typing import Tuple, Dict, Any, Optional
+
+
+class StopWatch:
+    __slots__ = ('start_time', 'stop_time', 'offset_seconds', 'multiplier')
+
+    def __init__(self, offset_seconds: float = 0, multiplier: float = 1, running: bool = True):
+        """
+        Create a StopWatch to start timing, by using timeit.default_timer().
+        A StopWatch will be created in the running state.
+        Call self.stop() to stop (or pause) the StopWatch.
+
+        Args:
+            offset_seconds: is an initial time offset.
+            multiplier: is an initial time multiplier (also applied to offset_seconds).
+            running: is a Boolean flag to set the stopwatch running (default True).
+        """
+        assert multiplier > 0, 'multiplier must be positive'
+        self.start_time = _timeit.default_timer()
+        self.stop_time = None if running else self.start_time
+        self.offset_seconds = offset_seconds
+        self.multiplier = multiplier
+
+    def copy(self, running: Optional[bool] = None) -> StopWatch:
+        """
+        Return a copy of this stop watch.
+
+        Args:
+            running: controls the running state of the copy.
+                If True, the copy will be running (continued),
+                if False, the copy will be stopped,
+                if None, the copy will be in the same state as this stop watch.
+        """
+        result = StopWatch(
+            offset_seconds=self.offset_seconds,
+            multiplier=self.multiplier,
+        )
+        result.start_time = self.start_time
+        result.stop_time = self.stop_time
+
+        if running is not None:
+            if running:
+                if self.stop_time is not None:
+                    # starting
+                    result.continu()
+            else:
+                if self.stop_time is None:
+                    # stopping
+                    result.stop()
+        return result
+
+    def start(self, offset_seconds: float = 0, multiplier: float = 1) -> None:
+        """
+        Mark the start time for the timer as now.
+        Cancels any previous start and stop.
+
+        Args:
+            offset_seconds: is an initial time offset.
+            multiplier: is an initial time multiplier (also applied to offset_seconds).
+        """
+        assert multiplier > 0, 'multiplier must be positive'
+        self.start_time = _timeit.default_timer()
+        self.stop_time = None
+        self.offset_seconds = offset_seconds
+        self.multiplier = multiplier
+
+    def stop(self) -> None:
+        """
+        Mark the stop time for the timer as now.
+        If the stop watch was already stopped, then this overrides the previous stop.
+        """
+        self.stop_time = _timeit.default_timer()
+
+    def continu(self) -> None:
+        """
+        Continue the timer, cancelling any previous stop.
+        Any 'pause' time between a stop and continu is not included in the elapsed time.
+        """
+        if self.stop_time is not None:
+            paused_seconds = _timeit.default_timer() - self.stop_time
+            self.offset_seconds -= paused_seconds
+            self.stop_time = None
+
+    @property
+    def running(self) -> bool:
+        """
+        Is this stopwatch running?
+        
+        Returns:
+            true if the stopwatch is running, false otherwise.
+        """
+        return self.stop_time is None
+
+    def set(self, seconds: float, multiplier: float = 1) -> None:
+        """
+        Set the stopwatch to the given number of seconds.
+        This stops the stopwatch and resets the time multiplier.
+
+        Args:
+            seconds: is the value to set the stop watch to.
+            multiplier: is reset the time multiplier (also applied to seconds).
+        """
+        self.start_time = _timeit.default_timer()
+        self.stop_time = self.start_time
+        self.offset_seconds = seconds
+        self.multiplier = multiplier
+
+    def add(self, seconds: float | StopWatch) -> None:
+        """
+        Add the given number of seconds to the stopwatch.
+        The number of seconds added is not affected by the time multiplier.
+        """
+        if isinstance(seconds, StopWatch):
+            seconds = seconds.seconds()
+        self.offset_seconds += seconds / self.multiplier
+
+    def subtract(self, seconds:  float | StopWatch) -> None:
+        """
+        Subtract the given number of seconds from the stopwatch.
+        The number of seconds subtracted is not affected by the time multiplier.
+        """
+        if isinstance(seconds, StopWatch):
+            seconds = seconds.seconds()
+        self.offset_seconds -= seconds / self.multiplier
+
+    def multiply(self, multiplier: float) -> None:
+        """
+        Multiply the rate of time by the given multiplier.
+        Multiplication is accumulative.
+        """
+        assert multiplier > 0, 'multiplier must be positive'
+        self.multiplier *= multiplier
+
+    def seconds(self) -> float:
+        """Number of seconds of elapsed time."""
+        if self.stop_time is None:
+            time = _timeit.default_timer() - self.start_time
+        else:
+            time = self.stop_time - self.start_time
+        return (time + self.offset_seconds) * self.multiplier
+
+    def minutes(self) -> float:
+        """Number of minutes elapsed."""
+        return self.seconds() / 60.0
+
+    def hours(self) -> float:
+        """Number of hours elapsed."""
+        return self.seconds() / 3600.0
+
+    def hms(self) -> Tuple[int, int, float]:
+        """
+        (hours, minutes, seconds) of elapsed time.
+        Hours and minutes will always be integers.
+        Only the absolute value of time will be reported
+        (i.e., if negative time offsets are used).
+        """
+        elapsed = abs(self.seconds())
+        hours, rem = divmod(elapsed, 3600)
+        minutes, seconds = divmod(rem, 60)
+        return int(hours), int(minutes), seconds
+
+    def __str__(self) -> str:
+        (hours, minutes, seconds) = self.hms()
+        if hours > 0:
+            return f'{hours:}:{minutes:0>2}:{seconds:06.3f}'
+        elif minutes > 0:
+            return f'{minutes:}:{seconds:06.3f}'
+        elif seconds >= 0.1:
+            return f'{seconds:.3f}'
+        elif seconds >= 0.01:
+            return f'{seconds:.4f}'
+        elif seconds >= 0.001:
+            return f'{seconds:.5f}'
+        elif seconds >= 0.0001:
+            return f'{seconds:.6f}'
+        else:
+            return str(seconds)
+
+    def __repr__(self) -> str:
+        offset_seconds = self.seconds()
+        multiplier = self.multiplier
+        running = self.running
+        name = self.__class__.__name__
+        return f'{name}(offset_seconds={offset_seconds}, multiplier={multiplier}, running={running})'
+
+    def __float__(self) -> float:
+        return self.seconds()
+
+    def __add__(self, other: float | StopWatch) -> StopWatch:
+        """The returned stop watch will be stopped."""
+        s = self.copy(running=False)
+        s.add(other)
+        return s
+
+    def __iadd__(self, other: float | StopWatch) -> StopWatch:
+        self.add(other)
+        return self
+
+    def __sub__(self, other: float | StopWatch) -> StopWatch:
+        """The returned stop watch will be stopped."""
+        s = self.copy(running=False)
+        s.subtract(other)
+        return s
+
+    def __isub__(self, other: float | StopWatch) -> StopWatch:
+        self.subtract(other)
+        return self
+
+    def __mul__(self, multiplier: float) -> StopWatch:
+        """The returned stop watch will be stopped."""
+        s = self.copy(running=False)
+        s.multiply(multiplier)
+        return s
+
+    def __imul__(self, multiplier: float) -> StopWatch:
+        self.multiply(multiplier)
+        return self
+
+    def __eq__(self, other: StopWatch) -> bool:
+        return self.seconds() == other.seconds()
+
+    def __ne__(self, other: StopWatch) -> bool:
+        return self.seconds() != other.seconds()
+
+    def __lt__(self, other: StopWatch) -> bool:
+        return self.seconds() < other.seconds()
+
+    def __gt__(self, other: StopWatch) -> bool:
+        return self.seconds() > other.seconds()
+
+    def __le__(self, other: StopWatch) -> bool:
+        return self.seconds() <= other.seconds()
+
+    def __ge__(self, other: StopWatch) -> bool:
+        return self.seconds() >= other.seconds()
+
+    def __hash__(self):
+        return hash(self.seconds())
+
+
+class ProgressCheck(StopWatch):
+    """
+    A class to support simple progress checking in a loop.
+    """
+
+    def __init__(self, reporting_seconds: float, first_check: Optional[float] = None):
+        """
+        Args:
+            reporting_seconds: how often (in seconds) should 'check' return True.
+                This is the minimum time between 'check' returning True.
+            first_check: when should 'check' first return True (in seconds).
+                If first_check is None the default value is reporting_seconds.
+        """
+        self.reporting_seconds = reporting_seconds
+        self.next_check = reporting_seconds if first_check is None else first_check
+        super().__init__()
+
+    def check(self) -> bool:
+        """
+        Returns:
+            True only if it has been long enough since the last True check.
+        """
+        seconds = self.seconds()
+        if seconds > self.next_check:
+            self.next_check = seconds + self.reporting_seconds
+            return True
+        else:
+            return False
+
+    def __bool__(self) -> bool:
+        return self.check()
+
+
+class timer(StopWatch):
+
+    def __init__(
+            self,
+            label: str = 'a',
+            start_message: str = '{label} timer started',
+            stop_message: str = '{label} timer stopped: {time}',
+            file=None,
+            logger=None
+    ):
+        """
+        Create a timer that will use a stop watch to time a section of code within a 'with' statement.
+        The timer label will be printed on entering the 'with' statement.
+        The timer label and time taken will be printed on exiting the 'with' statement.
+
+        Args:
+            label: A text string to label the timer.
+            start_message: How the 'enter' message will be formatted, including format fields.
+            stop_message: How the 'exit' message will be formatted, including format fields.
+            file: Where messages should be printed - an output stream.
+            logger: Where messages should be printed - a print function.
+
+        Available format fields:
+            {label} the label parameter as passed at construction time.
+            {time} the time rendered as per StopWatch.__str__.
+            {seconds} the time, in seconds.
+            {minutes} the time, in minutes.
+            {hours} the time, in hours.
+
+        Either file or logger may be specified, not both. If neither,
+        then the standard output is used.
+        """
+        super().__init__(running=False)
+        self._label = '' if label is None else label
+        self._start_message = start_message
+        self._stop_message = stop_message
+        self._file = file
+        self._logger = logger
+
+        if self._file is not None:
+            if self._logger is not None:
+                raise RuntimeError('cannot specify both file and logger')
+            self._print = self._print_file
+        elif self._logger is not None:
+            self._print = self._print_logger
+        else:
+            self._print = self._print_stdout
+
+    def _print(self, *args):
+        pass  # dynamically set at construction time
+
+    def _format_fields(self) -> Dict[str, Any]:
+        return {
+            'label': self._label,
+            'time': str(self),
+            'seconds': self.seconds(),
+            'minutes': self.minutes(),
+            'hours': self.hours(),
+        }
+
+    @staticmethod
+    def _print_stdout(*args):
+        print(*args)
+
+    def _print_file(self, *args):
+        print(*args, file=self._file)
+
+    def _print_logger(self, *args):
+        self._logger(*args)
+
+    def __enter__(self):
+        if self._start_message is not None:
+            self._print(self._start_message.format(**self._format_fields()))
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+        if self._stop_message is not None:
+            self._print(self._stop_message.format(**self._format_fields()))
+        return exc_val is None

compiled_knowledge-4.0.0a5.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: compiled-knowledge
+Version: 4.0.0a5
+Summary: A Python package for compiling and querying discrete probabilistic graphical models.
+Author-email: Barry Drake <barry@compiledknowledge.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ropeless/compiled_knowledge
+Project-URL: Issues, https://github.com/ropeless/compiled_knowledge/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: llvmlite
+Requires-Dist: numpy
+Dynamic: license-file
+
+CompiledKnowledge
+=================
+
+CompiledKnowledge is a Python package for compiling and querying discrete probabilistic graphical models.
+
+The aim of this repository is:
+  - to provide a Python library for compiling and querying
+    probabilistic graphical models, specifically discrete factor graphs
+  - to be extremely efficient, flexible, and easy to use
+  - to exhibit excellent design, code, and documentation
+  - support researchers and businesses wanting to explore and use 
+    probabilistic artificial intelligence.
+
+License
+=======
+
+See the file `LICENSE.txt`.
+
+
+More Information
+================
+
+For documentation see the Jupyter notebooks in the directory `docs`.
+
+For many example scripts, see the package `ck_demos`.
+
+For unit tests, see the package `ck_tests`.
+
+For information about contributing to this library, see `CONTRIBUTING.md`.
+
+The primary code repository for Compiled Knowledge is https://github.com/ropeless/compiled_knowledge. 
+
+For more information email [info@compiledknowledge.org](mailto:info@compiledknowledge.org).