1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
#!/usr/bin/env python3
"""Parity check: bin/bnw against the Bayesian Network Webserver itself.
The golden files in test/golden/ were produced by the *web application*
(gn-machines' bnw container, 2026-11-12): the six continuous traits of BNW's own
8-node example were posted to bn_genenet.php and run through
execute_bn_gom.php, and the container's /var/lib/genenet/bnw/c6x* files copied
out. So this compares our headless driver against the reference
implementation, not against a memory of it.
What is compared:
* continuous_input.txt -- the file the C programs read. Ours is written from
the matrix with a type line of 1s (continuous); the golden one has the same
numbers in the same order.
* structure_input.txt -- the learned, thresholded adjacency. This must match
exactly: same variables in the same order, same 0/1 cells.
Run: test/parity_check.py [--bin-dir DIR]
The driver needs the four BNW binaries (var_lib_genenet_bnw/build.sh). Without
them the check says so and exits 77 (skip), so it can sit in a test suite that
runs where BNW is not installed.
"""
import argparse
import subprocess
import sys
import tempfile
from pathlib import Path
HERE = Path(__file__).resolve().parent
REPO = HERE.parent
GOLDEN = HERE / "golden"
def fail(message):
print(f"FAIL: {message}")
return 1
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("--bin-dir", default=None,
help="where network_score/structure/get_kbest_* are")
args = parser.parse_args(argv)
command = [str(REPO / "bin" / "bnw"), "learn",
"--input", str(GOLDEN / "six_traits_matrix.tsv"),
"--keep", "--workdir", tempfile.mkdtemp(prefix="bnw-parity-")]
if args.bin_dir:
command += ["--bin-dir", args.bin_dir]
completed = subprocess.run(command, capture_output=True, text=True)
if completed.returncode == 77:
print("SKIP: the BNW binaries are not installed")
return 77
if completed.returncode != 0:
return fail(f"bnw learn failed ({completed.returncode}): {completed.stderr.strip()}")
workdir = Path(completed.stderr.splitlines()[-1].split("kept: ")[-1])
print(f"work directory: {workdir}")
# 1. the input file the C programs read
ours = (workdir / "continuous_input.txt").read_text()
golden = (GOLDEN / "six_traits_continuous_input.txt").read_text()
ours_rows = [line for line in ours.splitlines() if line.strip()]
golden_rows = [line for line in golden.splitlines() if line.strip()]
if len(ours_rows) != len(golden_rows):
return fail(f"continuous_input.txt: {len(ours_rows)} lines, "
f"golden has {len(golden_rows)}")
if ours_rows[0] != golden_rows[0]:
return fail("continuous_input.txt: header differs\n"
f" ours: {ours_rows[0]!r}\n golden: {golden_rows[0]!r}")
if ours_rows[1] != golden_rows[1]:
return fail("continuous_input.txt: type line differs\n"
f" ours: {ours_rows[1]!r}\n golden: {golden_rows[1]!r}")
print("ok continuous_input.txt matches the web application's")
# 2. the learned adjacency
ours = (workdir / "structure_input.txt").read_text()
golden = (GOLDEN / "six_traits_structure_input.txt").read_text()
def cells(text):
rows = [line.rstrip("\r") for line in text.splitlines() if line.strip()]
names = [cell for cell in rows[0].split("\t") if cell]
matrix = [[cell for cell in row.split("\t") if cell] for row in rows[1:]]
return names, matrix
ours_names, ours_matrix = cells(ours)
golden_names, golden_matrix = cells(golden)
if ours_names != golden_names:
return fail(f"structure_input.txt: variables differ\n"
f" ours: {ours_names}\n golden: {golden_names}")
if ours_matrix != golden_matrix:
print("FAIL: structure_input.txt: adjacency differs")
print(f" ours: {ours_matrix}")
print(f" golden: {golden_matrix}")
return 1
edges = sum(cell == "1" for row in ours_matrix for cell in row)
print(f"ok structure_input.txt matches the web application's ({edges} edge(s))")
# 3. the driver's own report agrees with the file
reported = [line.split("\t") for line in completed.stdout.splitlines()
if line and not line.startswith("#") and not line.startswith("from")]
reported_edges = {(row[0], row[1]) for row in reported if row[3] == "1"}
expected = {(ours_names[i], ours_names[j])
for i, row in enumerate(ours_matrix)
for j, cell in enumerate(row) if cell == "1"}
if reported_edges != expected:
return fail(f"the stdout edge list disagrees with structure_input.txt: "
f"{sorted(reported_edges)} vs {sorted(expected)}")
print(f"ok stdout reports the same {len(reported_edges)} edge(s)")
print("\nPARITY OK")
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
|