diff options
| author | Pjotr <wrk@bosa.lan> | 2026-11-13 13:27:06 +0000 |
|---|---|---|
| committer | Pjotr <wrk@bosa.lan> | 2026-11-13 13:27:06 +0000 |
| commit | e552bb6407718c986123e574a59494ca6184f2e2 (patch) | |
| tree | 8543d8f5fd3277525cc9685e65913dae30012201 /scripts/plot-bnw.py | |
| parent | d9e1bf7fd9da4e0bae6579b95fd0028296b997ac (diff) | |
| download | genenetwork4-e552bb6407718c986123e574a59494ca6184f2e2.tar.gz | |
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).
Diffstat (limited to 'scripts/plot-bnw.py')
| -rwxr-xr-x | scripts/plot-bnw.py | 235 |
1 files changed, 235 insertions, 0 deletions
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'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" ' + f'viewBox="0 0 {width} {height}" font-family="sans-serif" role="img">', + "<style>" + ".bg{fill:#fff}.fg{fill:#222}.muted{fill:#666}.axis{stroke:#bbb}" + ".survive{stroke:#1a5fb4;stroke-opacity:.9}.below{stroke:#999;stroke-opacity:.45;" + "stroke-dasharray:3 3}" + "@media (prefers-color-scheme: dark){.bg{fill:#111}.fg{fill:#eee}.muted{fill:#aaa}" + ".axis{stroke:#555}.survive{stroke:#6cb4ff}.below{stroke:#777}}" + "</style>", + f'<rect class="bg" width="{width}" height="{height}"/>', + ] + + +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('<defs><marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" ' + 'markerWidth="6" markerHeight="6" orient="auto-start-reverse">' + '<path d="M 0 0 L 10 5 L 0 10 z" fill="#1a5fb4"/></marker></defs>') + parts.append(f'<text class="fg" x="24" y="30" font-size="19">{escape(title)}</text>') + parts.append(f'<text class="muted" x="24" y="52" font-size="12">{escape(subtitle)}</text>') + + # 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'<line class="{css}" x1="{x1:.1f}" y1="{y1:.1f}" x2="{x2:.1f}" ' + f'y2="{y2:.1f}" stroke-width="{width:.2f}"{marker}/>') + if in_structure: + mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + parts.append(f'<text class="muted" x="{mx:.1f}" y="{my - 4:.1f}" font-size="10">' + f'{posterior:.2f}</text>') + + for name in names: + x, y = pos[name] + parts.append(f'<circle class="bg" cx="{x:.1f}" cy="{y:.1f}" r="{node_radius}" ' + f'stroke="#1a5fb4" stroke-width="1.2"/>') + parts.append(f'<text class="fg" x="{x:.1f}" y="{y + 4:.1f}" font-size="11" ' + f'text-anchor="middle">{escape(short(name))}</text>') + # 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'<text class="muted" x="{x:.1f}" y="{label_y:.1f}" font-size="9" ' + f'text-anchor="middle">{escape(name)}</text>') + + parts.append(f'<text class="muted" x="24" y="{H - 16}" font-size="11">' + 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.</text>') + parts.append("</svg>") + 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'<text class="fg" x="24" y="30" font-size="19">{escape(title)}</text>') + subtitle = parameters(doc) + parts.append(f'<text class="muted" x="24" y="52" font-size="12">{escape(subtitle)}</text>') + parts.append(f'<text class="muted" x="{left}" y="{top - 26}" font-size="11">' + f'from (rows) x to (columns); dark = high posterior</text>') + for i, name in enumerate(names): + parts.append(f'<text class="muted" x="{left - 6}" y="{top + i * cell + cell / 2 + 4:.1f}" ' + f'font-size="10" text-anchor="end">{escape(short(name))}</text>') + parts.append(f'<text class="muted" x="{top + i * cell + cell / 2:.1f}" y="{top - 8}" ' + f'font-size="10" text-anchor="start" transform="rotate(-60 ' + f'{top + i * cell + cell / 2:.1f} {top - 8})">{escape(short(name))}</text>') + 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'<rect class="bg" x="{x}" y="{y}" width="{cell - 2}" ' + f'height="{cell - 2}" stroke="#ddd" stroke-width="0.5"/>') + continue + shade = int(round(255 * (1 - min(max(value, 0.0), 1.0)) * 0.82)) + parts.append(f'<rect x="{x}" y="{y}" width="{cell - 2}" height="{cell - 2}" ' + f'fill="rgb({shade},{shade},{shade})" stroke="#1a5fb4" ' + f'stroke-width="{2 if value >= 0.5 else 0.6}"/>') + if cell >= 24 and value >= 0.995: + parts.append(f'<text class="muted" x="{x + cell / 2 - 1:.1f}" ' + f'y="{y + cell / 2 + 3:.1f}" font-size="9" text-anchor="middle">' + f'{value:.2f}</text>') + parts.append(f'<text class="muted" x="24" y="{H - 16}" font-size="11">' + 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.</text>') + parts.append("</svg>") + 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() |
