compiled-knowledge 4.0.0a20__cp312-cp312-musllinux_1_2_x86_64.whl

ck_demos/pgm_inference/demo_inferencing_wmc_and_mpe_sprinkler.py

@@ -0,0 +1,154 @@
+"""
+This is a simple demo creating then using a PGM model.
+"""
+
+from ck.pgm import PGM
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.mpe_program import MPEProgram
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+from ck_demos.utils.stop_watch import timer
+
+pgm = PGM()
+
+rain = pgm.new_rv('rain', ['no', 'yes'])
+sprinkler = pgm.new_rv('sprinkler', ['off', 'on'])
+grass = pgm.new_rv('grass', ['dry', 'damp', 'wet'])
+
+f_g = pgm.new_factor(grass, rain, sprinkler)  # same as a Conditional Probability Table (CPT)
+f_r = pgm.new_factor(rain)
+f_s = pgm.new_factor(sprinkler)
+
+# Instead of learning the parameter values from data, in this simple
+# demo we will hard code the parameter values.
+f_r.set_dense().set_flat(0.8, 0.2)
+f_s.set_dense().set_flat(0.9, 0.1)
+f_g.set_dense().set_flat(
+    # not raining  raining       # rain
+    # off on       off   on      # sprinkler
+    0.90, 0.01,    0.02, 0.01,   # grass dry
+    0.09, 0.01,    0.08, 0.04,   # grass damp
+    0.01, 0.98,    0.90, 0.95,   # grass wet
+)
+
+# ---------------------------------------
+#  Directly use the model
+# ---------------------------------------
+
+print('is_structure_bayesian', pgm.is_structure_bayesian)
+print('factors_are_cpts', pgm.factors_are_cpts())
+
+for inst in pgm.instances():
+    inst_str = ','.join(f'{rv}={state}' for rv, state in zip(pgm.rvs, inst))
+    inst_w = pgm.value_product(inst)
+    print(f'weight({inst_str}) = {inst_w}')
+
+# ---------------------------------------
+#  Compile the PGM for complex queries
+# ---------------------------------------
+
+with timer('compiling PGM'):
+    pgm_cct: PGMCircuit = DEFAULT_PGM_COMPILER(pgm)
+    wmc = WMCProgram(pgm_cct)
+circuit = pgm_cct.circuit_top.circuit
+print(f'number of ops: {circuit.number_of_op_nodes}')
+print(f'number of arcs: {circuit.number_of_arcs}')
+
+# ---------------------------------------
+#  Here are some example uses of a model
+# ---------------------------------------
+
+print()
+print('--------')
+print('Show selected probabilities')
+
+# What is the probability of 'not raining' and 'sprinkler off' and 'grass damp'?
+pr001 = wmc.probability(rain[0], sprinkler[0], grass[1])
+print(pgm.indicator_str(rain[0], sprinkler[0], grass[1]), 'Pr =', pr001)
+
+# What is the probability of 'not raining' and 'sprinkler on' and 'grass damp'?
+pr011 = wmc.probability(rain[0], sprinkler[1], grass[1])
+print(pgm.indicator_str(rain[0], sprinkler[1], grass[1]), 'Pr =', pr011)
+
+# What is the probability of 'not raining' and 'grass damp'?
+pr0_1 = wmc.probability(rain[0], grass[1])
+print(pgm.indicator_str(rain[0], grass[1]), 'Pr =', pr0_1)
+
+# What is the probability of 'grass damp'?
+pr__1 = wmc.probability(grass[1])
+print(pgm.indicator_str(grass[1]), 'Pr =', pr__1)
+
+# What is the probability of 'raining' given 'grass wet'?
+pr_val = wmc.probability(rain[1], condition=grass[2])
+pr_str  = pgm.indicator_str(rain[1])
+pr_cond = pgm.indicator_str(grass[2])
+print(f'Pr[{pr_str} | {pr_cond}] = {pr_val}')
+
+
+# Show the probability of each possible world
+print('--------')
+print('Show every possible world and its probability')
+for inst in pgm.instances_as_indicators():
+    pr_str = pgm.indicator_str(*inst)
+    pr_val = wmc.probability(*inst)
+    print(f'Pr[{pr_str}] = {pr_val}')
+
+print('--------')
+print('Show selected marginal distributions')
+
+# What is the marginal probability distribution over sprinkler?
+pr_sprinkler = wmc.marginal_distribution(sprinkler)
+print(f'Pr[{sprinkler}] = {pr_sprinkler}')
+
+# What is the marginal probability distribution over sprinkler,
+# given 'not raining' and 'grass wet'?
+condition = (rain[0], grass[2])
+print('Pr[{} | {}] = {}'.format(
+    sprinkler, pgm.indicator_str(*condition),
+    wmc.marginal_distribution(sprinkler, condition=condition)
+))
+
+# What is the marginal probability distribution over sprinkler,
+# given 'raining' and 'grass wet'?
+condition = (rain[1], grass[2])
+print('Pr[{} | {}] = {}'.format(
+    sprinkler,
+    pgm.indicator_str(*condition),
+    wmc.marginal_distribution(sprinkler, condition=condition)
+))
+
+
+print('--------')
+print('Show selected MAP results')
+
+pr, states = wmc.map(sprinkler, rain)
+print(f'MAP[{sprinkler}, {rain}] = {states} with probability = {pr}')
+
+pr, states = wmc.map(sprinkler, grass, condition=[grass[1], rain[0]])
+cond_str = pgm.indicator_str(grass[1], rain[0])
+print(f'MAP[{sprinkler}, {grass} | {cond_str}] = {states} with probability = {pr}')
+
+
+print('--------')
+print('Show selected MPE results')
+
+z = wmc.z
+mpe = MPEProgram(pgm_cct)
+
+mpe_result = mpe.mpe()
+print('MPE = {} with probability = {}'.format(mpe_result.mpe, mpe_result.wmc/z))
+
+mpe_result = mpe.mpe(grass[2])
+print('given wet grass: MPE = {} with probability = {}'.format(mpe_result.mpe, mpe_result.wmc/z))
+
+print('--------')
+print('Draw 20 independent samples from the probability distribution')
+num_samples = 20
+sampler = wmc.sample_direct()
+for i, sample in zip(range(1, 1 + num_samples), sampler):
+    sample_indicators = pgm.state_idxs_to_indicators(sample)
+    ind_str = pgm.indicator_str(*sample_indicators)
+    print(f'{i:2} {sample} {ind_str}')
+
+print('--------')
+print('Done.')

ck_demos/pgm_inference/demo_inferencing_wmc_student.py

@@ -0,0 +1,110 @@
+"""
+This is a simple demo creating then using a PGM model.
+"""
+
+from ck.pgm import PGM, rv_instances_as_indicators, Indicator, RandomVariable
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+from ck.probability.probability_space import Condition, check_condition
+
+# -------------------------------------------------------------------------
+# Construct the 'student' network from
+# Koller & Friedman, Probabilistic Graphical Models, 2009, Figure 3.4, p53.
+# -------------------------------------------------------------------------
+
+pgm = PGM()
+
+difficult = pgm.new_rv('difficult', ('Yes', 'No'))
+intelligent = pgm.new_rv('intelligent', ('Yes', 'No'))
+grade = pgm.new_rv('grade', ('1', '2', '3'))
+sat = pgm.new_rv('sat', ('High', 'Low'))
+letter = pgm.new_rv('letter', ('Yes', 'No'))
+
+pgm.new_factor(difficult).set_cpt().set_all(
+    (0.6, 0.4),
+)
+pgm.new_factor(intelligent).set_cpt().set_all(
+    (0.7, 0.3),
+)
+pgm.new_factor(grade, difficult, intelligent).set_cpt().set_all(
+    (0.3, 0.4, 0.3),
+    (0.05, 0.25, 0.7),
+    (0.9, 0.08, 0.02),
+    (0.5, 0.3, 0.2)
+)
+pgm.new_factor(sat, intelligent).set_cpt().set_all(
+    (0.95, 0.05),
+    (0.2, 0.8),
+)
+pgm.new_factor(letter, grade).set_cpt().set_all(
+    (0.1, 0.9),
+    (0.4, 0.6),
+    (0.99, 0.01),
+)
+
+# ---------------------------------------
+#  Compile the PGM
+# ---------------------------------------
+
+wmc = WMCProgram(DEFAULT_PGM_COMPILER(pgm))
+
+
+# ---------------------------------------
+#  Here are some example uses of a model
+# ---------------------------------------
+
+def show_probability(*indicators: Indicator, condition: Condition = ()):
+    """
+    Print the probability of the given indicators,
+    with an optional set of condition indicators.
+    """
+    condition = check_condition(condition)
+    indicator_str = pgm.indicator_str(*indicators)
+    probability = wmc.probability(*indicators, condition=condition)
+    if len(condition) == 0:
+        print(f'P({indicator_str}) = {probability:.4g}')
+    else:
+        condition_str = pgm.indicator_str(*condition)
+        print(f'P({indicator_str} | {condition_str}) = {probability:.4g}')
+
+
+def show_marginal_distribution(rv: RandomVariable, condition: Condition = ()):
+    """
+    Print the marginal probability distribution of the random variable,
+    with an optional set of condition indicators.
+    """
+    condition = check_condition(condition)
+    probabilities = wmc.marginal_distribution(rv, condition=condition)
+    if len(condition) == 0:
+        print(f'P({rv}) = {probabilities}')
+    else:
+        condition_str = pgm.indicator_str(*condition)
+        print(f'P({rv} | {condition_str}) = {probabilities}')
+
+
+print()
+show_probability(difficult('Yes'))
+show_probability(difficult('No'))
+
+print()
+show_probability(intelligent('Yes'))
+show_probability(intelligent('No'))
+
+print()
+show_probability(difficult('Yes'), intelligent('No'))
+show_probability(grade('3'), condition=intelligent('Yes'))
+show_probability(grade('3'), condition=(intelligent('Yes'), letter('Yes')))
+show_probability(intelligent('No'), condition=letter('Yes'))
+show_probability(intelligent('Yes'), condition=letter('Yes'))
+
+print()
+show_marginal_distribution(difficult)
+show_marginal_distribution(intelligent)
+show_marginal_distribution(grade)
+
+print()
+for example_condition in rv_instances_as_indicators(difficult, intelligent):
+    show_marginal_distribution(grade, condition=example_condition)
+
+print()
+print('Done.')

ck_demos/programs/demo_program_buffer.py

@@ -0,0 +1,24 @@
+from ck.circuit_compiler.interpret_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program.program_buffer import ProgramBuffer
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    cct = Circuit()
+    x = cct.new_vars(4)
+    y = cct.add(x[0], x[1])
+    z = cct.add(x[2], x[3])
+    top = cct.add(cct.mul(y, z, 12), 10)
+
+    raw_program: RawProgram = compile_circuit(top)
+    prog = ProgramBuffer(raw_program)
+
+    prog[:] = (4, 5, 6, 7)
+    result = prog.compute()
+    print('expect =', (4 + 5) * (6 + 7) * 12 + 10)
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/programs/demo_program_multi.py

@@ -0,0 +1,24 @@
+from ck.circuit_compiler.interpret_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program import Program
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    cct = Circuit()
+    x = cct.new_vars(4)
+    y = cct.add(x[0], x[1])
+    z = cct.add(x[2], x[3])
+    top1 = cct.add(1, cct.mul(y, -12))
+    top2 = cct.add(1, cct.mul(z, 12))
+
+    raw_program: RawProgram = compile_circuit(top1, top2)
+    prog = Program(raw_program)
+
+    result = prog(4, 5, 6, 7)
+    print('expect = [-107, 157]')
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/programs/demo_program_none.py

@@ -0,0 +1,19 @@
+from ck.circuit_compiler.interpret_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program import Program
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    circuit = Circuit()
+    input_vars = circuit.new_vars(4)
+
+    raw_program: RawProgram = compile_circuit(input_vars=input_vars)
+    prog = Program(raw_program)
+
+    result = prog(4, 5, 6, 7)
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/programs/demo_program_single.py

@@ -0,0 +1,23 @@
+from ck.circuit_compiler.interpret_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program import Program
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    cct = Circuit()
+    x = cct.new_vars(4)
+    y = cct.add(x[0], x[1])
+    z = cct.add(x[2], x[3])
+    top = cct.add(cct.mul(y, z, 12), -10)
+
+    raw_program: RawProgram = compile_circuit(top)
+    prog = Program(raw_program)
+
+    result = prog(4, 5, 6, 7)
+    print('expect =', (4 + 5) * (6 + 7) * 12 - 10)
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/programs/demo_raw_program_interpreted.py

@@ -0,0 +1,21 @@
+from ck.circuit_compiler.interpret_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    cct = Circuit()
+    x = cct.new_vars(4)
+    y = cct.add(x[0], x[1])
+    z = cct.add(x[2], x[3])
+    top = cct.add(cct.mul(y, z, 12), -10)
+
+    prog: RawProgram = compile_circuit(top)
+
+    result = prog([4, 5, 6, 7])
+    print('expect =', (4 + 5) * (6 + 7) * 12 - 10)
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/programs/demo_raw_program_llvm.py

@@ -0,0 +1,21 @@
+from ck.circuit_compiler.llvm_compiler import compile_circuit
+from ck.circuit import Circuit
+from ck.program.raw_program import RawProgram
+
+
+def main() -> None:
+    cct = Circuit()
+    x = cct.new_vars(4)
+    y = cct.add(x[0], x[1])
+    z = cct.add(x[2], x[3])
+    top = cct.add(cct.mul(y, z, 12), -10)
+
+    prog: RawProgram = compile_circuit(top)
+
+    result = prog([4, 5, 6, 7])
+    print('expect =', (4 + 5) * (6 + 7) * 12 - 10)
+    print('result =', result)
+
+
+if __name__ == '__main__':
+    main()

ck_demos/sampling/check_sampler.py

@@ -0,0 +1,71 @@
+"""
+This demo script can be used to see how well samplers perform.
+"""
+import random
+
+from ck.pgm import PGM
+from ck.utils.random_extras import random_permutation
+from ck_demos.utils.sample_model import sample_model, STANDARD_SAMPLERS, BURN_IN
+
+# Parameters for random PGM
+num_of_rvs = 5
+states_per_rv = 3
+proportion_zeros = 0.1
+
+# Experiment parameters
+num_of_trials = 3
+limit_conditioning = None
+num_of_samples = 100 * (states_per_rv ** num_of_rvs)
+seed = None
+
+# Formatting options
+show_each_analysis = False
+
+
+def main():
+    # Manage randomness, if requested
+    if seed is not None:
+        random.seed(seed)
+
+    # Create a random PGM
+    pgm = PGM()
+    rvs = [pgm.new_rv(f'x_{i}', states_per_rv) for i in range(num_of_rvs)]
+
+    # Add unary factors to all but the first rv (uniform prior).
+    for rv in rvs[1:]:
+        pgm.new_factor(rv).set_dense().set_uniform()
+    # Make the first rv the child of all others (random probabilities).
+    f = pgm.new_factor(*rvs).set_dense().set_stream(random.random)
+
+    # Force some zero probabilities.
+    num_to_zero = int(f.number_of_parameters * proportion_zeros + 0.5)
+    if num_to_zero > 0:
+        to_zero = random_permutation(f.number_of_parameters)[:num_to_zero]
+        for param_idx in to_zero:
+            f.set_param_value(param_idx, 0)
+
+    # Make the PGM a Bayesian network.
+    f.normalise_cpt()
+
+    samplers_str = ', '.join([name for name in STANDARD_SAMPLERS.keys()])
+    print(f'Samplers:                   {samplers_str}')
+    print(f'Number of trials:           {num_of_trials}')
+    print(f'Number of samples:          {num_of_samples}')
+    print(f'States per RV:              {states_per_rv}')
+    print(f'Burn in (where used):       {BURN_IN}')
+    print(f'Random seed:                {seed}')
+
+    sample_model(
+        pgm,
+        STANDARD_SAMPLERS,
+        num_of_trials,
+        num_of_samples,
+        limit_conditioning=limit_conditioning,
+        show_each_analysis=show_each_analysis
+    )
+
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/sampling/demo_marginal_direct_sampler.py

@@ -0,0 +1,40 @@
+import random
+
+from ck import example
+from ck.pgm import PGM
+from ck.pgm_compiler import factor_elimination
+from ck.pgm_circuit.marginals_program import MarginalsProgram
+from ck.pgm_circuit import PGMCircuit
+from ck.probability.empirical_probability_space import EmpiricalProbabilitySpace
+
+num_of_samples_to_show = 100
+num_of_samples_to_calculate = 10_000
+rand_seed = None
+
+
+def main():
+    if rand_seed is not None:
+        random.seed(rand_seed)
+
+    pgm: PGM = example.Rain()
+
+    pgm_cct: PGMCircuit = factor_elimination.compile_pgm(pgm)
+    marginals = MarginalsProgram(pgm_cct)
+    sampler = marginals.sample_direct()
+
+    # Show some samples
+    for sample in sampler.take(num_of_samples_to_show):
+        print(sample)
+    print()
+
+    # Show empirical and theoretical marginal distribution for each random variable
+    sample_pr = EmpiricalProbabilitySpace(sampler.rvs, sampler.take(num_of_samples_to_calculate))
+    for rv in pgm.rvs:
+        print(rv, sample_pr.marginal_distribution(rv), marginals.marginal_distribution(rv))
+    print()
+
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/sampling/demo_uniform_sampler.py

@@ -0,0 +1,38 @@
+import random
+
+from ck import example
+from ck.pgm import PGM
+from ck.pgm_compiler import factor_elimination
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.probability.empirical_probability_space import EmpiricalProbabilitySpace
+
+num_of_samples = 100
+seed = None
+
+
+def main():
+    if seed is not None:
+        random.seed(seed)
+
+    pgm: PGM = example.Rain()
+    pgm_cct: PGMCircuit = factor_elimination.compile_pgm(pgm)
+    wmc = WMCProgram(pgm_cct)
+    sampler = wmc.sample_uniform()
+
+    # Show some samples
+    for sample in sampler.take(num_of_samples):
+        print(sample)
+    print()
+
+    # Show empirical marginal distribution for each random variable
+    pr = EmpiricalProbabilitySpace(sampler.rvs, sampler.take(100_000))
+    for rv in pgm.rvs:
+        print(rv, pr.marginal_distribution(rv))
+    print()
+
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()

ck_demos/sampling/demo_wmc_direct_sampler.py

@@ -0,0 +1,40 @@
+import random
+
+from ck import example
+from ck.pgm import PGM
+from ck.pgm_compiler import factor_elimination
+from ck.pgm_circuit import PGMCircuit
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.probability.empirical_probability_space import EmpiricalProbabilitySpace
+
+num_of_samples_to_show = 100
+num_of_samples_to_calculate = 10_000
+rand_seed = None
+
+
+def main():
+    if rand_seed is not None:
+        random.seed(rand_seed)
+
+    pgm: PGM = example.Rain()
+
+    pgm_cct: PGMCircuit = factor_elimination.compile_pgm(pgm)
+    wmc = WMCProgram(pgm_cct)
+    sampler = wmc.sample_direct()
+
+    # Show some samples
+    for sample in sampler.take(num_of_samples_to_show):
+        print(sample)
+    print()
+
+    # Show empirical and theoretical marginal distribution for each random variable
+    sample_pr = EmpiricalProbabilitySpace(sampler.rvs, sampler.take(num_of_samples_to_calculate))
+    for rv in pgm.rvs:
+        print(rv, sample_pr.marginal_distribution(rv), wmc.marginal_distribution(rv))
+    print()
+
+    print('Done.')
+
+
+if __name__ == '__main__':
+    main()