compiled-knowledge 4.0.0a20__cp312-cp312-win32.whl

ck_demos/utils/compare.py

@@ -0,0 +1,120 @@
+import gc
+from typing import Sequence
+
+from ck.circuit_compiler import NamedCircuitCompiler
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import NamedPGMCompiler
+from ck_demos.utils.stop_watch import StopWatch
+
+
+def compare(
+        pgms: Sequence[PGM],
+        pgm_compilers: Sequence[NamedPGMCompiler],
+        cct_compilers: Sequence[NamedCircuitCompiler],
+        *,
+        cache_circuits: bool = True,
+        break_between_pgms: bool = True,
+        comma_numbers: bool = True,
+        print_header: bool = True,
+        sep: str = '  ',
+) -> None:
+    """
+    For each combination of the given arguments, construct a PGMCircuit (using a
+    PGMCompiler) and then a WMCProgram (using a CircuitCompiler). The resulting
+    WMCProgram is executed 1000 times to estimate compute time.
+
+    For each PGM, PGM compiler, and circuit compiler, a line is printed showing:
+         PGM,
+         PGM compiler name,
+         Circuit compiler name,
+         number of circuit operations,
+         PGMCircuit compile time,
+         WMCProgram compile time,
+         WMC compute time.
+
+    The print output is formatted using fixed column width.
+
+    Args:
+        pgms: a sequence of PGM objects.
+        pgm_compilers: a sequence of named PGM compilers.
+        cct_compilers: a sequence of named circuit compilers.
+        cache_circuits: if true, then circuits are reused across different circuit compilers.
+        break_between_pgms: if true, print a blank line  between different workload PGMs.
+        comma_numbers: if true, commas are used in large numbers.
+        print_header: if true, a header line is printed.
+        sep: column separator.
+    """
+    # Work out column widths for names.
+    col_pgm_name: int = max(3, max(len(pgm.name) for pgm in pgms))
+    col_pgm_compiler_name: int = max(12, max(len(pgm_compiler.name) for pgm_compiler in pgm_compilers))
+    col_cct_compiler_name: int = max(12, max(len(cct_compiler.name) for cct_compiler in cct_compilers))
+    col_cct_ops: int = 10
+    col_pgm_compile_time: int = 16
+    col_cct_compile_time: int = 16
+    col_execute_time: int = 10
+
+    # Print formatting
+    comma: str = ',' if comma_numbers else ''
+
+    if print_header:
+        print('PGM'.ljust(col_pgm_name), end=sep)
+        print('PGM-compiler'.ljust(col_pgm_compiler_name), end=sep)
+        print('CCT-compiler'.ljust(col_cct_compiler_name), end=sep)
+        print('CCT-ops'.rjust(col_cct_ops), end=sep)
+        print('PGM-compile-time'.rjust(col_pgm_compile_time), end=sep)
+        print('CCT-compile-time'.rjust(col_cct_compile_time), end=sep)
+        print('Run-time'.rjust(col_execute_time))
+
+    # Variables for when cache_circuits is true
+    prev_pgm = None
+    prev_pgm_compiler = None
+
+    for pgm in pgms:
+        pgm_name: str = pgm.name.ljust(col_pgm_name)
+        for pgm_compiler in pgm_compilers:
+            pgm_compiler_name: str = pgm_compiler.name.ljust(col_pgm_compiler_name)
+            for cct_compiler in cct_compilers:
+                cct_compiler_name: str = cct_compiler.name.ljust(col_cct_compiler_name)
+
+                print(pgm_name, end=sep)
+                print(pgm_compiler_name, end=sep)
+                print(cct_compiler_name, end=sep)
+
+                try:
+                    time = StopWatch()
+
+                    if cache_circuits and pgm is prev_pgm and pgm_compiler is prev_pgm_compiler:
+                        print(f'{"":{col_cct_ops}}', end=sep)
+                        print(f'{"":{col_pgm_compile_time}}', end=sep)
+                    else:
+                        gc.collect()
+                        time.start()
+                        pgm_cct: PGMCircuit = pgm_compiler(pgm)
+                        time.stop()
+                        num_ops: int = pgm_cct.circuit_top.circuit.number_of_operations
+                        print(f'{num_ops:{col_cct_ops}{comma}}', end=sep)
+                        print(f'{time.seconds():{col_pgm_compile_time}{comma}.3f}', end=sep)
+                        prev_pgm = pgm
+                        prev_pgm_compiler = pgm_compiler
+
+                    gc.collect()
+                    time.start()
+                    # `pgm_cct` will always be set but the IDE can't work that out.
+                    # noinspection PyUnboundLocalVariable
+                    wmc = WMCProgram(pgm_cct, compiler=cct_compiler.compiler)
+                    time.stop()
+                    print(f'{time.seconds():{col_cct_compile_time}{comma}.3f}', end=sep)
+
+                    gc.collect()
+                    time.start()
+                    for _ in range(1000):
+                        wmc.compute()
+                    time.stop()
+                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end='')
+                except Exception as err:
+                    print(repr(err), end='')
+                print()
+        if break_between_pgms:
+            print()

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()