compiled-knowledge 4.0.0a20__cp312-cp312-macosx_10_13_x86_64.whl

ck/pgm_circuit/wmc_program.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import random
+from typing import Sequence, Optional, Tuple
+
+from ck.circuit_compiler import CircuitCompiler
+from ck.pgm import RandomVariable
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.program_with_slotmap import ProgramWithSlotmap
+from ck.pgm_circuit.support.compile_circuit import compile_results, DEFAULT_CIRCUIT_COMPILER
+from ck.probability.probability_space import ProbabilitySpace, Condition
+from ck.program.program_buffer import ProgramBuffer
+from ck.program.raw_program import RawProgram
+from ck.sampling.sampler import Sampler
+from ck.sampling.sampler_support import SamplerInfo, get_sampler_info
+from ck.sampling.uniform_sampler import UniformSampler
+from ck.sampling.wmc_direct_sampler import WMCDirectSampler
+from ck.sampling.wmc_gibbs_sampler import WMCGibbsSampler
+from ck.sampling.wmc_metropolis_sampler import WMCMetropolisSampler
+from ck.sampling.wmc_rejection_sampler import WMCRejectionSampler
+from ck.utils.np_extras import NDArray
+from ck.utils.random_extras import Random
+
+
+class WMCProgram(ProgramWithSlotmap, ProbabilitySpace):
+    """
+    A class for computing Weighted Model Count (WMC).
+    """
+
+    def __init__(
+            self,
+            pgm_circuit: PGMCircuit,
+            const_parameters: bool = True,
+            compiler: CircuitCompiler = DEFAULT_CIRCUIT_COMPILER,
+    ):
+        """
+        Construct a WMCProgram object.
+
+        Args:
+            pgm_circuit: The circuit representing a PGM.
+            const_parameters: if True then any circuit variable representing a parameter value will
+                be made 'const' in the resulting program.
+        """
+        raw_program: RawProgram = compile_results(
+            pgm_circuit=pgm_circuit,
+            results=(pgm_circuit.circuit_top,),
+            const_parameters=const_parameters,
+            compiler=compiler,
+        )
+        ProgramWithSlotmap.__init__(
+            self,
+            ProgramBuffer(raw_program),
+            pgm_circuit.slot_map,
+            pgm_circuit.rvs,
+            pgm_circuit.conditions,
+        )
+        self._raw_program: RawProgram = raw_program
+        self._number_of_indicators: int = pgm_circuit.number_of_indicators
+        self._z_cache: Optional[float] = None
+
+        if not const_parameters:
+            # set the parameter slots
+            self.vars[pgm_circuit.number_of_indicators:] = pgm_circuit.parameter_values
+
+    def wmc(self, *condition: Condition) -> float:
+        self.set_condition(*condition)
+        return self.compute().item()
+
+    @property
+    def z(self) -> float:
+        if self._z_cache is None:
+            number_of_indicators: int = self._number_of_indicators
+            slots: NDArray = self.vars
+            old_vals: NDArray = slots[:number_of_indicators].copy()
+            slots[:number_of_indicators] = 1
+            self._z_cache = self.compute().item()
+            slots[:number_of_indicators] = old_vals
+
+        return self._z_cache
+
+    def sample_uniform(
+            self,
+            rvs: Optional[RandomVariable | Sequence[RandomVariable]] = None,
+            *,
+            condition: Condition = (),
+            rand: Random = random,
+    ) -> Sampler:
+        """
+        Create a sampler that performs uniform sampling of
+        the state space of the given random variables, rvs.
+
+        The sampler will yield state lists, where the state
+        values are co-indexed with rvs, or self.rvs if rvs is None.
+
+        This sampler is not affected by and does not affect
+        the state of input slots.
+
+        Args:
+            rvs: the list of random variables to sample; the
+                yielded state vectors are co-indexed with rvs; if None,
+                then the self.rvs are used; if rvs is a single
+                random variable, then single samples are yielded.
+            condition: is a collection of zero or more conditioning indicators.
+            rand: provides the stream of random numbers.
+
+        Returns:
+            a Sampler object (UniformSampler).
+        """
+        return UniformSampler(
+            rvs=(self.rvs if rvs is None else rvs),
+            condition=condition,
+            rand=rand,
+        )
+
+    def sample_direct(
+            self,
+            rvs: Optional[RandomVariable | Sequence[RandomVariable]] = None,
+            *,
+            condition: Condition = (),
+            rand: Random = random,
+            chain_pairs: Sequence[Tuple[RandomVariable, RandomVariable]] = (),
+            initial_chain_condition: Condition = (),
+    ) -> Sampler:
+        """
+        Create an inverse-transform sampler, which uses the fact that
+        probabilities are exactly computable using a WMC.
+
+        The sampler will yield state lists, where the state
+        values are co-indexed with rvs, or self.rvs if rvs is None.
+
+        Given 'n' random variables, and 'm' number of indicators, for each yielded sample, this method:
+        * calls rand.random() once and rand.randrange(...) n times,
+        * calls self.program().compute_result() at least once and <= 1 + m.
+
+        Args:
+            rvs: the list of random variables to sample; the
+                yielded state vectors are co-indexed with rvs; if None,
+                then the WMC rvs are used; if rvs is a single
+                random variable, then single samples are yielded.
+            condition: is a collection of zero or more conditioning indicators.
+            rand: provides the stream of random numbers.
+            chain_pairs: is a collection of pairs of random variables, each random variable
+                must be in the given rvs. Given a pair (from_rv, to_rv) the state of from_rv is used
+                as a condition for to_rv prior to generating a sample.
+            initial_chain_condition: are condition indicators (just like condition)
+                for the initialisation of the 'to_rv' random variables mentioned in chain_pairs.
+
+        Returns:
+            a Sampler object (WMCDirectSampler).
+        """
+        sampler_info: SamplerInfo = get_sampler_info(
+            program_with_slotmap=self,
+            rvs=rvs,
+            condition=condition,
+            chain_pairs=chain_pairs,
+            initial_chain_condition=initial_chain_condition,
+        )
+
+        return WMCDirectSampler(
+            sampler_info=sampler_info,
+            raw_program=self._raw_program,
+            rand=rand,
+        )
+
+    def sample_rejection(
+            self,
+            rvs: Optional[RandomVariable | Sequence[RandomVariable]] = None,
+            *,
+            condition: Condition = (),
+            rand: Random = random,
+    ) -> Sampler:
+        """
+        Create a sampler to perform rejection sampling.
+
+        The sampler will yield state lists, where the state
+        values are co-indexed with rvs, or self.rvs if rvs is None.
+
+        The method uniformly samples states and uses an adaptive 'max weight'
+        to reduce unnecessary rejection.
+
+        After each sample is yielded, the WMC indicator variables will
+        be left set as per the yielded states of rvs and conditions.
+
+        Args:
+            rvs: the list of random variables to sample; the
+                yielded state vectors are co-indexed with rvs; if None,
+                then the WMC rvs are used; if rvs is a single
+                random variable, then single samples are yielded.
+            condition: is a collection of zero or more conditioning indicators.
+            rand: provides the stream of random numbers.
+
+        Returns:
+            a Sampler object (WMCRejectionSampler).
+        """
+        sampler_info: SamplerInfo = get_sampler_info(
+            program_with_slotmap=self,
+            rvs=rvs,
+            condition=condition,
+        )
+        z = self.wmc(*condition)
+
+        return WMCRejectionSampler(
+            sampler_info=sampler_info,
+            raw_program=self._raw_program,
+            rand=rand,
+            z=z,
+        )
+
+    def sample_gibbs(
+            self,
+            rvs: Optional[RandomVariable | Sequence[RandomVariable]] = None,
+            *,
+            condition: Condition = (),
+            skip: int = 0,
+            burn_in: int = 0,
+            pr_restart: float = 0,
+            rand: Random = random,
+    ) -> Sampler:
+        """
+        Create a sampler to perform Gibbs sampling.
+
+        The sampler will yield state lists, where the state
+        values are co-indexed with rvs, or self.rvs if rvs is None.
+
+        After each sample is yielded, the WMC indicator vars will
+        be left set as per the yielded states of rvs and conditions.
+
+        Args:
+            rvs: the list of random variables to sample; the
+                yielded state vectors are co-indexed with rvs; if None,
+                then the WMC rvs are used; if rvs is a single
+                random variable, then single samples are yielded.
+            condition: is a collection of zero or more conditioning indicators.
+            skip: is an integer >= 0 specifying how may samples to discard
+                for each sample provided. Values > 0 can be used to de-correlate adjacent samples.
+            burn_in: how many iterations to perform after
+                initialisation before yielding a sample.
+            pr_restart: the chance of re-initialising each
+                iteration. If restarted then burn-in is performed again.
+            rand: provides the stream of random numbers.
+
+        Returns:
+            a Sampler object (WMCGibbsSampler).
+        """
+        if skip < 0:
+            raise RuntimeError('skip must be non-negative')
+        if burn_in < 0:
+            raise RuntimeError('burn_in must be non-negative')
+
+        sampler_info: SamplerInfo = get_sampler_info(
+            program_with_slotmap=self,
+            rvs=rvs,
+            condition=condition,
+        )
+
+        return WMCGibbsSampler(
+            sampler_info=sampler_info,
+            raw_program=self._raw_program,
+            rand=rand,
+            skip=skip,
+            burn_in=burn_in,
+            pr_restart=pr_restart,
+        )
+
+    def sample_metropolis(
+            self,
+            rvs: Optional[RandomVariable | Sequence[RandomVariable]] = None,
+            *,
+            condition: Condition = (),
+            skip: Optional[int] = None,
+            burn_in: int = 0,
+            pr_restart: float = 0,
+            rand: Random = random,
+    ) -> Sampler:
+        """
+        Create a sampler to perform Metropolis-Hastings sampling.
+
+        The sampler will yield state lists, where the state
+        values are co-indexed with rvs, or self.rvs if rvs is None.
+
+        After each sample is yielded, the WMC indicator vars will
+        be left set as per the yielded states of rvs and conditions.
+
+        Args:
+            rvs: the list of random variables to sample; the
+                yielded state vectors are co-indexed with rvs; if None,
+                then the WMC rvs are used; if rvs is a single
+                random variable, then single samples are yielded.
+            condition: is a collection of zero or more conditioning indicators.
+            skip: is an optional integer >= 0 specifying how may samples to discard
+                for each sample provided. Values > 0 can be used to de-correlate adjacent samples.
+                Default value = len(rvs)
+            burn_in: how many iterations to perform after initialisation
+                before yielding a sample.
+            pr_restart: the chance of re-initialising each iteration. If
+                restarted then burn-in is performed again.
+            rand: provides the stream of random numbers.
+
+        Returns:
+            a Sampler object (WMCMetropolisSampler).
+        """
+        if skip is not None and skip < 0:
+            raise RuntimeError('skip must be non-negative')
+        if burn_in < 0:
+            raise RuntimeError('burn_in must be non-negative')
+
+        sampler_info: SamplerInfo = get_sampler_info(
+            program_with_slotmap=self,
+            rvs=rvs,
+            condition=condition,
+        )
+
+        if skip is None:
+            skip = len(sampler_info.sample_rvs)
+
+        return WMCMetropolisSampler(
+            sampler_info=sampler_info,
+            raw_program=self._raw_program,
+            rand=rand,
+            skip=skip,
+            burn_in=burn_in,
+            pr_restart=pr_restart,
+        )

ck/pgm_compiler/__init__.py

@@ -0,0 +1,2 @@
+from .pgm_compiler import PGMCompiler
+from .named_pgm_compilers import NamedPGMCompiler, DEFAULT_PGM_COMPILER

ck/pgm_compiler/ace/__init__.py

@@ -0,0 +1 @@
+from .ace import compile_pgm, copy_ace_to_default_location, default_ace_location, ace_available

ck/pgm_compiler/ace/ace.py

@@ -0,0 +1,299 @@
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, List, Tuple
+
+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
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.slot_map import SlotMap
+from ck.utils.local_config import config
+from ck.utils.np_extras import NDArrayFloat64
+from ck.utils.tmp_dir import tmp_dir
+
+
+def compile_pgm(
+        pgm: PGM,
+        const_parameters: bool = True,
+        *,
+        ace_dir: Optional[Path | str] = None,
+        jar_dir: Optional[Path | str] = None,
+        print_output: bool = False,
+        m_bytes: int = 1512,
+        check_is_bayesian_network: bool = True,
+) -> PGMCircuit:
+    """
+    Compile the PGM to an arithmetic circuit, using Ace.
+
+    This is a wrapper for Ace.
+    Ace compiles a Bayesian network into an Arithmetic Circuit.
+    Provided by the Automated Reasoning Group, University of California Los Angeles.
+    Ace requires the Java Runtime Environment (JRE) version 8 or higher.
+    See http://reasoning.cs.ucla.edu/ace/
+
+    Conforms to the `PGMCompiler` protocol.
+
+    Args:
+        pgm: The PGM to compile.
+        const_parameters: If true, the potential function parameters will be circuit
+            constants, otherwise they will be circuit variables.
+        ace_dir: Directory containing Ace. If not provided then the directory this module is in is used.
+        jar_dir: Directory containing Ace jar files. If not provided, then `ace_dir` is used.
+        print_output: if true, the output from Ace is printed.
+        m_bytes: requested megabytes for the Java Virtual Machine (using the java "-Xmx" argument).
+        check_is_bayesian_network: if true, then the PGM will be checked to confirm it is a Bayesian network.
+
+    Returns:
+        a PGMCircuit object.
+
+    Raises:
+        RuntimeError: if Ace files are not found, including a helpful message.
+        ValueError: if `check_is_bayesian_network` is true and the PGM is not a Bayesian network.
+        CalledProcessError: if executing Ace failed.
+    """
+    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()
+    files: _AceFiles = _find_ace_files(ace_dir, jar_dir)
+    net_file_name = 'to_compile.net'
+    main_class = 'edu.ucla.belief.ace.AceCompile'
+    class_path: str = classpath_separator.join(
+        str(f) for f in [files.ace_jar, files.inflib_jar, files.jdom_jar]
+    )
+    ace_cmd: List[str] = [
+        java,
+        '-cp',
+        class_path,
+        f'-DACEC2D={files.c2d}',
+        f'-Xmx{int(m_bytes)}m',
+        main_class,
+        net_file_name,
+    ]
+
+    with tmp_dir():
+        # Render the PGM to a .net file to be read by Ace
+        with open(net_file_name, 'w') as file:
+            node_names: List[str] = render_bayesian_network(pgm, file, check_structure_bayesian=False)
+
+        # Run Ace
+        ace_result: subprocess.CompletedProcess = subprocess.run(ace_cmd, capture_output=(not print_output), text=True)
+        if ace_result.returncode != 0:
+            raise subprocess.CalledProcessError(
+                returncode=ace_result.returncode,
+                cmd=' '.join(ace_cmd),
+                output=None if print_output else ace_result.stdout,
+                stderr=None if print_output else ace_result.stderr,
+            )
+
+        # Parse the literal map output from Ace
+        with open(f'{net_file_name}.lmap', 'r') as file:
+            literal_map: LiteralMap = read_lmap(file, node_names=node_names)
+
+        # Parse the arithmetic circuit output from Ace
+        with open(f'{net_file_name}.ac', 'r') as file:
+            circuit_top: CircuitNode
+            slot_map: SlotMap
+            parameter_values: NDArrayFloat64
+            circuit_top, slot_map, parameter_values = read_nnf_with_literal_map(
+                file,
+                indicators=pgm.indicators,
+                literal_map=literal_map,
+                const_parameters=const_parameters,
+            )
+
+    # Consistency checking
+    number_of_indicators: int = pgm.number_of_indicators
+    number_of_parameters: int = parameter_values.shape[0]
+    assert circuit_top.circuit.number_of_vars == number_of_indicators + number_of_parameters, 'consistency check'
+
+    return PGMCircuit(
+        rvs=pgm.rvs,
+        conditions=(),
+        circuit_top=circuit_top,
+        number_of_indicators=number_of_indicators,
+        number_of_parameters=number_of_parameters,
+        slot_map=slot_map,
+        parameter_values=parameter_values,
+    )
+
+
+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,
+) -> None:
+    """
+    Copy Ace files from the given directories into the default directory.
+
+    Args:
+        ace_dir: Directory containing Ace.
+        jar_dir: Directory containing Ace jar files. If not provided, then `ace_dir` is used.
+
+    Raises:
+        RuntimeError: if Ace files are not found, including a helpful message .
+        IOError: if the copy fails.
+
+    Assumes:
+        ace_dir exists and is not the same as the installation directory.
+    """
+    install_location: Path = default_ace_location()
+
+    if ace_dir is None or ace_dir == install_location:
+        raise RuntimeError(f'Ace directory cannot be the default directory')
+
+    files: _AceFiles = _find_ace_files(ace_dir, jar_dir)
+
+    to_copy = [files.ace_jar, files.inflib_jar, files.jdom_jar] + files.c2d_options
+
+    for file in to_copy:
+        shutil.copyfile(file, install_location / file.name)
+
+
+def default_ace_location() -> Path:
+    """
+    Get the default location for Ace files.
+
+    This function checks the local config for the variable
+    CK_ACE_LOCATION. If that is not available, then the
+    directory that this Python module is in will be used.
+    """
+    return Path(config.get('CK_ACE_LOCATION', Path(__file__).parent))
+
+
+@dataclass
+class _AceFiles:
+    ace_jar: Path
+    inflib_jar: Path
+    jdom_jar: Path
+    c2d: Path
+    c2d_options: List[Path]
+
+
+def _find_java() -> Tuple[str, str]:
+    """
+    What to call the Java executable and classpath separator.
+
+    Returns:
+        (java, classpath_separator)
+
+    Raises:
+        RuntimeError: if not found, including a helpful message.
+    """
+    if sys.platform == 'win32':
+        return 'java.exe', ';'
+    elif sys.platform == 'darwin':
+        return 'java', ':'
+    elif sys.platform.startswith('linux'):
+        return 'java', ':'
+    else:
+        raise RuntimeError(f'cannot infer java for platform {sys.platform!r}')
+
+
+def _find_ace_files(
+        ace_dir: Optional[Path | str],
+        jar_dir: Optional[Path | str],
+) -> _AceFiles:
+    """
+    Look for the needed Ace files.
+
+    Raises:
+        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)
+
+    if not ace_dir.is_dir():
+        raise RuntimeError(f'Ace directory does not exist: {ace_dir}')
+    if not jar_dir.is_dir():
+        raise RuntimeError(f'Ace jar directory does not exist: {jar_dir}')
+
+    ace_jar = jar_dir / 'ace.jar'
+    inflib_jar = jar_dir / 'inflib.jar'
+    jdom_jar = jar_dir / 'jdom.jar'
+
+    missing: List[str] = [
+        jar.name
+        for jar in [ace_jar, inflib_jar, jdom_jar]
+        if not jar.is_file()
+    ]
+    if len(missing) > 0:
+        raise RuntimeError(f'Ace jars missing (ensure Ace is properly installed): {", ".join(missing)}')
+
+    c2d_options: List[Path] = [
+        file
+        for file in ace_dir.iterdir()
+        if file.is_file() and file.name.startswith('c2d')
+    ]
+    c2d: Path
+    if len(c2d_options) == 0:
+        raise RuntimeError(f'cannot find c2d in the Ace directory: {ace_dir}')
+    if len(c2d_options) == 1:
+        c2d = next(iter(c2d_options))
+    else:
+        if sys.platform == 'win32':
+            c2d = ace_dir / 'c2d_windows.exe'
+        elif sys.platform == 'darwin':
+            c2d = ace_dir / 'c2d_osx'
+        elif sys.platform.startswith('linux'):
+            c2d = ace_dir / 'c2d_linux'
+        else:
+            raise RuntimeError(f'cannot infer c2d executable name for platform {sys.platform!r}')
+
+    if not c2d.is_file():
+        raise RuntimeError(f'cannot find c2d: {c2d}')
+
+    return _AceFiles(
+        c2d=c2d,
+        c2d_options=c2d_options,
+        ace_jar=ace_jar,
+        inflib_jar=inflib_jar,
+        jdom_jar=jdom_jar,
+    )