about summary refs log tree commit diff
path: root/test/parity_check.py
blob: 490caa12fe0c0946d257a723a0903476ea1f1d40 (plain)
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:]))