From e552bb6407718c986123e574a59494ca6184f2e2 Mon Sep 17 00:00:00 2001 From: Pjotr Date: Fri, 13 Nov 2026 13:27:06 +0000 Subject: plot/bnw: two SVG figures, drawn the way /plot/gemma draws one Post the reply from /compute/bnw back and get an SVG: the same plumbing as /plot/gemma and /plot/bulklmm (plot::render, PLOT_PYTHON + BNW_PLOTTER, image/ svg+xml, the plotter's line in x-plot-summary), nothing recomputed. Two figures, because one cannot say what the other can: * the network (default): nodes on a circle, one arrow per edge that survived the threshold, arrow width and label = the edge's posterior, and the below-threshold edges as faint dotted lines -- so a reader sees what was *considered* as well as what survived, which is half of why the posterior table exists; * ?kind=posterior: every candidate edge as a cell in a matrix, dark = high posterior, outlined cells are the ones above the threshold. The diagram cannot show that an edge came within 0.02 of the threshold; this can. Pure-Python SVG, standard library only: no graphviz in the deployment. A circular layout is less pretty than a force-directed one and is deterministic, which matters more for a figure that accompanies a JSON result. Node labels keep the distinguishing tail of a long id, with the full name beside the node. Verified live on the dev instance: POST /plot/bnw with a saved /compute/bnw reply returns 200, image/svg+xml, 5 256 bytes, and x-plot-summary naming the strongest edge (Trait2 -> Trait1, posterior 1.000); ?kind=posterior returns the second figure. tests/plot.rs covers both figures plus the 422s (not a BNW result, unknown kind). --- scripts/plot-bnw.py | 235 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 235 insertions(+) create mode 100755 scripts/plot-bnw.py (limited to 'scripts/plot-bnw.py') diff --git a/scripts/plot-bnw.py b/scripts/plot-bnw.py new file mode 100755 index 0000000..248c4cb --- /dev/null +++ b/scripts/plot-bnw.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +"""Network diagram of a GN4 BNW result, as one SVG panel. + +Input is the JSON response of POST /gn4/compute/bnw (saved as-is). The rows +are positional -- from, to, posterior, in_structure -- so this reads +`meta.columns` to find them. + + python3 plot-bnw.py network.json -o network.svg --trait BXD::hippocampus + +Two figures, chosen with --kind: + + network the learned structure: nodes on a circle, an arrow per edge that + survived the threshold, labelled with its posterior, drawn thicker + the stronger the posterior. Edges below the threshold are faint + dotted lines, so a reader can see what was *considered* as well as + what survived. + posterior every candidate edge as a cell in a matrix, dark = high posterior, + with the surviving ones outlined. This is the view that says how + close to the threshold an edge was, which the diagram cannot. + +Standard library only; writes plain SVG (light/dark aware). A network diagram +without graphviz keeps the deployment dependency-free: a circular layout is +less pretty than a force-directed one, but it is deterministic, and a reader of +a 10-node network does not need the extra cleverness. +""" +import argparse +import json +import math +import sys + + +def read_edges(doc): + """The posted reply's rows as (from, to, posterior, in_structure) tuples.""" + if "data" not in doc: + sys.exit(f"no 'data' member (error response?): {str(doc)[:200]}") + columns = (doc.get("meta") or {}).get("columns") or ["from", "to", "posterior", "in_structure"] + idx = {name: i for i, name in enumerate(columns)} + for wanted in ("from", "to", "posterior"): + if wanted not in idx: + sys.exit(f"the rows have no {wanted!r} column: {columns}") + rows = [] + for row in doc["data"]: + if not isinstance(row, list) or len(row) < 3: + continue + try: + posterior = float(row[idx["posterior"]]) + except (TypeError, ValueError): + continue + in_structure = bool(row[idx["in_structure"]]) if "in_structure" in idx else posterior >= 0.5 + rows.append((str(row[idx["from"]]), str(row[idx["to"]]), posterior, in_structure)) + if not rows: + sys.exit("no edges to plot") + return rows, doc + + +def parameters(doc): + """The parameter note the endpoint writes, if it is there.""" + for note in doc.get("notes") or []: + if note.startswith("Parameters:"): + return note.split(".", 1)[0] + return "" + + +def head(width, height): + return [ + f'', + "", + f'', + ] + + +def network_svg(rows, doc, label, title_override): + names = [] + for source, target, _, _ in rows: + for name in (source, target): + if name not in names: + names.append(name) + names.sort() + n = len(names) + radius = max(110.0, 26.0 * n) + W = int(2 * radius + 360) + H = int(2 * radius + 150) + cx, cy = radius + 40, radius + 100 + angle = {name: (2 * math.pi * i / n) - math.pi / 2 for i, name in enumerate(names)} + pos = {name: (cx + radius * math.cos(angle[name]), cy + radius * math.sin(angle[name])) + for name in names} + # Shorten each arrow so it stops at the node circle, not at its centre. + node_radius = 17.0 + + def edge_points(source, target): + x1, y1 = pos[source] + x2, y2 = pos[target] + dx, dy = x2 - x1, y2 - y1 + length = math.hypot(dx, dy) or 1.0 + return (x1 + dx / length * node_radius, y1 + dy / length * node_radius, + x2 - dx / length * (node_radius + 7), y2 - dy / length * (node_radius + 7)) + + title = title_override or f"{label}: Bayesian network" + subtitle = parameters(doc) + survived = sum(1 for row in rows if row[3]) + subtitle = (subtitle + ". " if subtitle else "") + \ + f"{n} variables, {len(rows)} candidate edges, {survived} above the threshold" + + parts = head(W, H) + parts.append('' + '') + parts.append(f'{escape(title)}') + parts.append(f'{escape(subtitle)}') + + # Faint first, so the surviving edges sit on top. + for source, target, posterior, in_structure in sorted(rows, key=lambda r: r[3]): + x1, y1, x2, y2 = edge_points(source, target) + css = "survive" if in_structure else "below" + width = 0.8 + 3.2 * posterior if in_structure else 0.8 + marker = ' marker-end="url(#arrow)"' if in_structure else "" + parts.append(f'') + if in_structure: + mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + parts.append(f'' + f'{posterior:.2f}') + + for name in names: + x, y = pos[name] + parts.append(f'') + parts.append(f'{escape(short(name))}') + # The full name below the circle, when it was shortened above it. + if short(name) != name: + label_y = y + node_radius + 13 * (1 if math.sin(angle[name]) >= 0 else -1) + 4 + parts.append(f'{escape(name)}') + + parts.append(f'' + f'Solid arrows survived the threshold, width and label = edge posterior; dotted ' + f'lines were considered and did not. A posterior is the share of the k-best ' + f'networks containing the edge, not a p-value.') + parts.append("") + top = max(rows, key=lambda row: row[2]) + return "\n".join(parts), ( + f"BNW network over {n} variables. {survived} of {len(rows)} candidate edges survive the " + f"threshold; the strongest is {top[0]} -> {top[1]} (posterior {top[2]:.3f}).") + + +def posterior_svg(rows, doc, label, title_override): + names = sorted({name for source, target, _, _ in rows for name in (source, target)}) + n = len(names) + cell = max(16, min(34, int(760 / max(n, 1)))) + left, top = 210, 110 + W, H = left + cell * n + 40, top + cell * n + 90 + posterior = {(source, target): value for source, target, value, _ in rows} + title = title_override or f"{label}: edge posteriors" + + parts = head(W, H) + parts.append(f'{escape(title)}') + subtitle = parameters(doc) + parts.append(f'{escape(subtitle)}') + parts.append(f'' + f'from (rows) x to (columns); dark = high posterior') + for i, name in enumerate(names): + parts.append(f'{escape(short(name))}') + parts.append(f'{escape(short(name))}') + for i, source in enumerate(names): + for j, target in enumerate(names): + value = posterior.get((source, target)) + x, y = left + j * cell, top + i * cell + if value is None: + parts.append(f'') + continue + shade = int(round(255 * (1 - min(max(value, 0.0), 1.0)) * 0.82)) + parts.append(f'') + if cell >= 24 and value >= 0.995: + parts.append(f'' + f'{value:.2f}') + parts.append(f'' + f'A cell is the posterior of that directed edge; outlined cells survive the ' + f'threshold. Blank cells are pairs the search did not report.') + parts.append("") + top_edge = max(rows, key=lambda row: row[2]) + return "\n".join(parts), ( + f"BNW edge posteriors over {n} variables; strongest {top_edge[0]} -> {top_edge[1]} " + f"(posterior {top_edge[2]:.3f}).") + + +def short(name, limit=9): + """Node labels on a small circle: keep the distinguishing tail of an id.""" + if len(name) <= limit: + return name + return "…" + name[-limit + 1:] + + +def escape(text): + return (str(text).replace("&", "&").replace("<", "<").replace(">", ">")) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + parser.add_argument("result", help="saved /compute/bnw response (JSON)") + parser.add_argument("-o", "--out", default="bnw_network.svg") + parser.add_argument("--trait", default="", help="label for the title") + parser.add_argument("--title", default=None, help="override the title text") + parser.add_argument("--kind", choices=("network", "posterior"), default="network", + help="network diagram (default) or the posterior matrix") + args = parser.parse_args() + + doc = json.load(open(args.result)) + rows, doc = read_edges(doc) + label = args.trait or "BNW" + if args.kind == "posterior": + svg, summary = posterior_svg(rows, doc, label, args.title) + else: + svg, summary = network_svg(rows, doc, label, args.title) + with open(args.out, "w") as handle: + handle.write(svg + "\n") + print(summary) + + +if __name__ == "__main__": + main() -- cgit 1.4.1