compiled-knowledge 4.0.0a20__cp313-cp313-musllinux_1_2_x86_64.whl

ck_demos/pgm_compiler/demo_marginals_program.py

@@ -0,0 +1,53 @@
+from ck import example
+from ck.pgm import RandomVariable, RVMap
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.marginals_program import MarginalsProgram
+from ck.pgm_compiler import factor_elimination, PGMCompiler
+
+
+COMPILER: PGMCompiler = factor_elimination.compile_pgm_best_jointree
+
+
+def main() -> None:
+    pgm = example.Cancer()
+
+    print(f'Compiling PGM {pgm.name!r} to a Circuit')
+    pgm_cct: PGMCircuit = COMPILER(pgm)
+
+    print('Getting Marginals Program')
+    marginals = MarginalsProgram(pgm_cct)
+
+    print()
+    print('Showing Program results, weighted model count for each instance:')
+    for indicators in pgm.instances_as_indicators():
+        instance_as_str = pgm.indicator_str(*indicators)
+        wmc_value = marginals.wmc(*indicators)
+        pgm_value = pgm.value_product_indicators(*indicators)
+        print(f'  {instance_as_str:75} {wmc_value:.6f} {pgm_value:.6f}')
+
+    print()
+    print('Showing Program results, marginal distribution for each rv:')
+    marginals.compute_conditioned()
+    for rv in pgm.rvs:
+        distribution = marginals.result_for_rv(rv)
+        distribution_str = ', '.join(f'{state} = {value:.6f}' for state, value in zip(rv.states, distribution))
+        print(f'  {(str(rv) + ":"):12} {distribution_str}')
+
+    print()
+    print('Showing Program results, marginal distribution, given cancer = True:')
+
+    cancer: RandomVariable = RVMap(pgm).cancer
+    condition = cancer('True')
+
+    marginals.compute_conditioned(condition)
+    for rv in pgm.rvs:
+        distribution = marginals.result_for_rv(rv)
+        distribution_str = ', '.join(f'{state} = {value:.6f}' for state, value in zip(rv.states, distribution))
+        print(f'  {(str(rv) + ":"):12} {distribution_str}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/demo_mpe_program.py

@@ -0,0 +1,55 @@
+from ck import example
+from ck.pgm import RVMap, RandomVariable
+from ck.pgm_circuit.mpe_program import MPEProgram, MPEResult
+from ck.pgm_compiler import factor_elimination,  PGMCompiler
+from ck.pgm_circuit import PGMCircuit
+
+
+COMPILER: PGMCompiler = factor_elimination.compile_pgm_best_jointree
+
+
+def main() -> None:
+    pgm = example.Cancer()
+
+    rv_map = RVMap(pgm)
+    pollution: RandomVariable = rv_map.pollution
+    smoker: RandomVariable = rv_map.smoker
+    cancer: RandomVariable = rv_map.cancer
+    xray: RandomVariable = rv_map.xray
+    dyspnoea: RandomVariable = rv_map.dyspnoea
+
+    print(f'Compiling PGM {pgm.name!r} to a Circuit')
+    pgm_cct: PGMCircuit = COMPILER(pgm)
+
+    print('Getting MPE Program')
+    mpe = MPEProgram(pgm_cct)
+
+    print()
+    print('Showing Program results:')
+
+    conditions = [
+        [],
+        [smoker('True')],
+        [cancer('True')],
+        [pollution('low')],
+        [xray('positive')],
+        [pollution('high'), dyspnoea('False')],
+    ]
+
+    z: float = pgm.value_product_indicators()
+
+    for condition in conditions:
+        result: MPEResult = mpe.mpe(*condition)
+
+        condition_str = pgm.condition_str(*condition)
+        result_str = pgm.instance_str(result.mpe)
+        pr = result.wmc / z
+
+        print(f'MPE[{condition_str}] = {result_str} with pr = {pr}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/demo_pgm_compiler.py

@@ -0,0 +1,38 @@
+from ck.circuit_compiler import llvm_compiler
+from ck import example
+from ck.pgm_compiler import factor_elimination
+from ck.pgm_circuit import PGMCircuit
+from ck.program.program_buffer import ProgramBuffer
+
+
+PGM_COMPILER = factor_elimination.compile_pgm_best_jointree
+CCT_COMPILER = llvm_compiler.compile_circuit
+
+
+def main() -> None:
+    pgm = example.Rain()
+
+    print(f'Compiling PGM {pgm.name!r} to a Circuit')
+    pgm_cct: PGMCircuit = PGM_COMPILER(pgm)
+
+    print('Compiling Circuit to a Program')
+    prog = ProgramBuffer(CCT_COMPILER(pgm_cct.circuit_top))
+    slot_map = pgm_cct.slot_map
+
+    print('Showing Program results')
+    for indicators in pgm.instances_as_indicators():
+        prog[:] = 0
+        for ind in indicators:
+            prog[slot_map[ind]] = 1
+
+        instance_as_str = pgm.indicator_str(*indicators)
+        program_value = prog.compute().item()
+        pgm_value = pgm.value_product_indicators(*indicators)
+        print(f'  {instance_as_str:75} {program_value:.6f} {pgm_value:.6f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/demo_recursive_conditioning.py

@@ -0,0 +1,33 @@
+from ck import example
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import recursive_conditioning
+
+
+def main() -> None:
+    pgm: PGM = example.Rain()
+
+    pgm_cct: PGMCircuit = recursive_conditioning.compile_pgm(pgm)
+
+    print(f'PGM: {pgm.name}')
+    print()
+    print(f'Circuit:')
+    pgm_cct.dump()
+    print()
+
+    wmc = WMCProgram(pgm_cct)
+
+    print('Showing Program results:')
+    for indicators in pgm.instances_as_indicators():
+        instance_as_str = pgm.indicator_str(*indicators)
+        wmc_value = wmc.wmc(*indicators)
+        pgm_value = pgm.value_product_indicators(*indicators)
+        print(f'  {instance_as_str:80} {wmc_value:.6f} {pgm_value:.6f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/demo_variable_elimination.py

@@ -0,0 +1,33 @@
+from ck import example
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import variable_elimination
+
+
+def main() -> None:
+    pgm: PGM = example.Rain()
+
+    pgm_cct: PGMCircuit = variable_elimination.compile_pgm(pgm)
+
+    print(f'PGM: {pgm.name}')
+    print()
+    print(f'Circuit:')
+    pgm_cct.dump()
+    print()
+
+    wmc = WMCProgram(pgm_cct)
+
+    print('Showing Program results:')
+    for indicators in pgm.instances_as_indicators():
+        instance_as_str = pgm.indicator_str(*indicators)
+        wmc_value = wmc.wmc(*indicators)
+        pgm_value = pgm.value_product_indicators(*indicators)
+        print(f'  {instance_as_str:80} {wmc_value:.6f} {pgm_value:.6f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/demo_wmc_program.py

@@ -0,0 +1,29 @@
+from ck import example
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+
+
+def main() -> None:
+    pgm = example.Cancer()
+
+    print(f'Compiling PGM {pgm.name!r} to a Circuit')
+    pgm_cct: PGMCircuit = DEFAULT_PGM_COMPILER(pgm)
+
+    print('Getting WMC Program')
+    wmc = WMCProgram(pgm_cct)
+
+    print()
+    print('Showing Program results:')
+    for indicators in pgm.instances_as_indicators():
+        instance_as_str = pgm.indicator_str(*indicators)
+        wmc_value = wmc.wmc(*indicators)
+        pgm_value = pgm.value_product_indicators(*indicators)
+        print(f'  {instance_as_str:75} {wmc_value:.6f} {pgm_value:.6f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_compiler/time_fe_compiler.py

@@ -0,0 +1,93 @@
+from ck import example
+from ck.circuit import CircuitNode, Circuit
+from ck.circuit_compiler import DEFAULT_CIRCUIT_COMPILER
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_compiler.factor_elimination import DEFAULT_PRODUCT_SEARCH_LIMIT, _circuit_tables_from_join_tree
+from ck.pgm_compiler.support.circuit_table import CircuitTable
+from ck.pgm_compiler.support.clusters import min_degree, Clusters
+from ck.pgm_compiler.support.factor_tables import FactorTables, make_factor_tables
+from ck.pgm_compiler.support.join_tree import JoinTree, clusters_to_join_tree
+from ck.program import ProgramBuffer, RawProgram
+from ck_demos.utils.stop_watch import timer
+
+
+def main() -> None:
+    """
+    Time components of the compilation chain for factor elimination.
+
+    Process:
+        example -> PGM
+        min_degree -> Clusters
+        clusters_to_join_tree -> JoinTree
+        join_tree_to_circuit -> PGMCircuit
+        default circuit compiler -> RawProgram
+        execute program
+    """
+    with timer('make PGM') as make_pgm_time:
+        pgm: PGM = example.Mildew()
+
+    with timer('make clusters') as make_clusters_time:
+        clusters: Clusters = min_degree(pgm)
+
+    with timer('make join tree') as make_join_tree_time:
+        join_tree: JoinTree = clusters_to_join_tree(clusters)
+
+    with timer('make factor tables') as make_factor_tables_time:
+        factor_tables: FactorTables = make_factor_tables(
+            pgm=pgm,
+            const_parameters=True,
+            multiply_indicators=True,
+            pre_prune_factor_tables=False,
+        )
+
+    with timer('make circuit tables') as make_circuit_tables_time:
+        top_table: CircuitTable = _circuit_tables_from_join_tree(
+            factor_tables,
+            join_tree,
+            DEFAULT_PRODUCT_SEARCH_LIMIT,
+        )
+    top: CircuitNode = top_table.top()
+    circuit: Circuit = top.circuit
+
+    orig_size = circuit.number_of_op_nodes
+    with timer('remove unreachable nodes') as remove_unreachable_time:
+        circuit.remove_unreachable_op_nodes(top)
+    print(f'    saving  {orig_size - circuit.number_of_op_nodes:10,}')
+    print(f'    leaving {circuit.number_of_op_nodes:10,}')
+
+    with timer('make PGMCircuit') as make_pgm_time:
+        pgm_circuit = PGMCircuit(
+            rvs=tuple(pgm.rvs),
+            conditions=(),
+            circuit_top=top,
+            number_of_indicators=factor_tables.number_of_indicators,
+            number_of_parameters=factor_tables.number_of_parameters,
+            slot_map=factor_tables.slot_map,
+            parameter_values=factor_tables.parameter_values,
+        )
+
+    with timer('make program') as make_program_time:
+        program: RawProgram = DEFAULT_CIRCUIT_COMPILER(pgm_circuit.circuit_top)
+
+    program_buffer = ProgramBuffer(program)
+    with timer('execute program') as execute_program_time:
+        program_buffer.compute()
+
+    print()
+    print(f'make PGM            {make_pgm_time.seconds():5.2f}')
+    print(f'make clusters       {make_clusters_time.seconds():5.2f}')
+    print(f'make join_tree      {make_join_tree_time.seconds():5.2f}')
+    print(f'make factor tables  {make_factor_tables_time.seconds():5.2f}')
+    print(f'make circuit tables {make_circuit_tables_time.seconds():5.2f}')
+    print(f'remove unreachables {remove_unreachable_time.seconds():5.2f}')
+    print(f'make PGM circuit    {make_pgm_time.seconds():5.2f}')
+    print(f'make program        {make_program_time.seconds():5.2f}')
+    print(f'execute program     {execute_program_time.seconds():5.2f}')
+
+    print()
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/pgm_inference/demo_inferencing_basic.py

@@ -0,0 +1,188 @@
+"""
+Demo script to show the foundational processes PGM compilation
+and inference.
+"""
+
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.support.compile_circuit import DEFAULT_CIRCUIT_COMPILER
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+from ck.program import RawProgram, ProgramBuffer
+
+pgm = PGM()
+
+# =============================================================
+# Define PGM random variables
+# =============================================================
+A = pgm.new_rv('A', 2)
+B = pgm.new_rv('B', 2)
+C = pgm.new_rv('C', 2)
+D = pgm.new_rv('D', 3)
+
+# =============================================================
+# Show the possible worlds
+# =============================================================
+print()
+print("The PGM worlds...")
+print(tuple(str(rv) for rv in pgm.rvs))
+for world in pgm.instances():
+    print(world)
+
+# =============================================================
+# Add some PGM factors
+# (configure each factor to have a dense potential function)
+# =============================================================
+factor_AB = pgm.new_factor(A, B)
+factor_BCD = pgm.new_factor(B, C, D)
+factor_B = pgm.new_factor(B)
+
+f_AB = factor_AB.set_dense()
+f_BCD = factor_BCD.set_dense()
+f_B = factor_B.set_dense()
+
+f_AB[0, 0] = 0.9
+f_AB[1, 0] = 0.8
+f_AB[0, 1] = 0.1
+f_AB[1, 1] = 0.2
+
+f_BCD[0, 0, 0] = 0
+f_BCD[1, 0, 0] = 1
+f_BCD[0, 1, 0] = 1
+f_BCD[1, 1, 0] = 0
+f_BCD[0, 0, 1] = 1
+f_BCD[1, 0, 1] = 0
+f_BCD[0, 1, 1] = 0
+f_BCD[1, 1, 1] = 1
+f_BCD[0, 0, 2] = 0
+f_BCD[1, 0, 2] = 1
+f_BCD[0, 1, 2] = 1
+f_BCD[1, 1, 2] = 0
+
+f_B[0] = 2.3
+f_B[1] = 4.5
+
+# =============================================================
+# Show the weight of each possible world
+# =============================================================
+print()
+print('The PGM world factors and weights...')
+z = 0
+print(tuple(str(rv) for rv in pgm.rvs), 'weights...')
+for world in pgm.instances():
+    weight = pgm.value_product(world)
+    print(world, list(pgm.factor_values(world)), weight)
+    z += weight
+print('z =', z)
+
+# =============================================================
+# Getting and printing indicators
+# =============================================================
+print()
+
+A_is_0 = A[0]  # Get the indicator for A=0
+print('Indicator for A = 0:', A_is_0)
+
+A_is_0_as_str = pgm.indicator_str(A[0])  # Get the indicator in human-readable form
+print('Indicator string for A = 0:', A_is_0_as_str)
+
+print('A possible world:', pgm.indicator_str(A[0], B[1], C[0], D[2]))
+
+# =============================================================
+# Convert the PGM into an arithmetic circuit
+# =============================================================
+
+pgm_cct: PGMCircuit = DEFAULT_PGM_COMPILER(pgm)  # Compiles the PGM into a circuit
+
+# Get a reference to the circuit object
+cct = pgm_cct.circuit_top.circuit
+
+print()
+print('Dump of the arithmetic circuit')
+cct.dump()
+
+# =============================================================
+# Compile the arithmetic circuit into a program
+# =============================================================
+
+# Get a reference to the top node of the arithmetic circuit
+cct_top = pgm_cct.circuit_top
+
+# Compile the circuit into a program
+raw_program: RawProgram = DEFAULT_CIRCUIT_COMPILER(cct_top)
+program = ProgramBuffer(raw_program)
+
+# =============================================================
+# Use the program to compute the partition function, z
+# =============================================================
+
+program[:] = 1  # set all input slots to 1
+z = program.compute()  # run the program
+
+print()
+print('Program computed z =', z)
+
+# =============================================================
+# Use the program to compute the weight of A=0,B=1,C=0,D=0
+# =============================================================
+
+program[:] = 0  # set all input slots to 0
+program[0] = 1  # A=0
+program[3] = 1  # B=1
+program[4] = 1  # C=0
+program[6] = 1  # D=0
+w = program.compute()
+
+print()
+print('Program computed w(A=0, B=1, C=0, D=0) =', w)
+
+# =============================================================
+# Use the program to compute the probability of A=0 and B=1
+# =============================================================
+
+program[:] = 1  # set all input slots to 1
+program[1] = 0  # exclude A=1
+program[2] = 0  # exclude B=0
+w = program.compute()
+
+print()
+print('Program computed P(A=0, B=1) =', (w / z))
+
+# =============================================================
+# Using a slot map
+# =============================================================
+
+slots = pgm_cct.slot_map  # get the slot map
+
+program[:] = 1  # set all input slots to 1
+program[slots[B[1]]] = 0  # exclude B=1
+program[slots[C[0]]] = 0  # exclude C=0
+w = program.compute()
+
+print()
+print('Program computed P(B=0, C=1) =', (w / z))
+
+# =============================================================
+# Using a WMCProgram object with built in slot map
+# =============================================================
+
+# Compile the circuit as a WMCProgram object
+wmc = WMCProgram(pgm_cct)
+
+wmc[:] = 0  # set all input slots to 0
+wmc[B[1]] = 1  # set B=1 to 1
+wmc[D[2]] = 1  # set C=2 to 1
+wmc[A] = 1  # set all A indicators to 1
+wmc[C] = 1  # set all C indicators to 1
+
+print()
+print('Program computed P(B=1, D=2) =', (wmc.compute() / z))
+
+# Here is the easy way to do it
+print()
+print('Program computed P(B=0, D=2) =', wmc.probability(B[0], D[2]))
+print('Program computed P(B=1, D=2) =', wmc.probability(B[1], D[2]))
+print('Program computed P(D=2) =', wmc.probability(D[2]))
+
+print()
+print('Done.')

ck_demos/pgm_inference/demo_inferencing_mpe_cancer.py

@@ -0,0 +1,45 @@
+"""
+Demonstrate how to do MEP inference on a PGM
+"""
+
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.mpe_program import MPEProgram, MPEResult
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+
+pgm = PGM()
+pollution = pgm.new_rv('pollution', ('low', 'high'))
+smoker = pgm.new_rv('smoker', ('true', 'false'))
+cancer = pgm.new_rv('cancer', ('true', 'false'))
+xray = pgm.new_rv('xray', ('positive', 'negative'))
+dyspnoea = pgm.new_rv('dyspnoea', ('true', 'false'))
+pgm.new_factor(pollution).set_dense().set_flat(0.9, 0.1)
+pgm.new_factor(smoker).set_dense().set_flat(0.3, 0.7)
+pgm.new_factor(cancer, pollution, smoker).set_dense().set_flat(0.03, 0.001, 0.05, 0.02, 0.97, 0.999, 0.95, 0.98)
+pgm.new_factor(xray, cancer).set_dense().set_flat(0.9, 0.2, 0.1, 0.8)
+pgm.new_factor(dyspnoea, cancer).set_dense().set_flat(0.65, 0.3, 0.35, 0.7)
+
+pgm_cct: PGMCircuit = DEFAULT_PGM_COMPILER(pgm)
+mpe = MPEProgram(pgm_cct)
+
+
+# How we will render an mpe_result
+def mpe_str(_mpe_result: MPEResult) -> str:
+    global pgm
+    return ', '.join([
+        pgm.indicator_str(rv[state])
+        for rv, state in zip(mpe.trace_rvs, _mpe_result.mpe)
+    ])
+
+
+# What is the most likely situation (unconditioned MPE)
+mpe_result: MPEResult = mpe.mpe()
+print(mpe_str(mpe_result))
+
+# What is the MPE given smoker = true
+mpe_result: MPEResult = mpe.mpe(smoker('true'))
+print(mpe_str(mpe_result))
+
+# What is the MPE given pollution = high and xray = negative
+mpe_result: MPEResult = mpe.mpe(pollution('high'), xray('negative'))
+print(mpe_str(mpe_result))