Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/queues/loco_scratch_sepsis_20261005.txt

@@ -0,0 +1,5 @@
+# No-pretraining ablation, cross-cohort pilot (user decision 2026-10-05): held-out sepsis (split hoL_ye2026_sepsis =
+# ImMicro + Imperial + Giroux + Liu), K = 1000, every denoiser weight randomly initialised (--init random), full
+# training at the pretraining lr 2e-4, milestones every 50k steps up to 200k (each sampled and scored), saturation stop
+# disabled (frac 0: stop only if a whole block does not improve), patience 10 evaluations of 1,000 steps.
+loco|hoL_ye2026_sepsis|1000|scratchsat|full|2e-4|--init|random|--block|50000|--max-steps|200000|--saturation-frac|0|--eval-every|1000|--patience|10

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/mask_rescore.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""No-pretraining LOCO pilot (2026-10-05): rescore held-out arms with the genes that NO training cohort measured set to
+zero in the generated cells (CPU only).
+
+Why: a model trained from scratch on the training cohorts never receives a loss for a gene none of them measured, so its
+output there is untrained.  For held-out sepsis (split hoL_ye2026_sepsis) 46 panel genes are measured in sepsis but in
+none of ImMicro / Imperial / Giroux / Liu; the scratch arm puts ~91 % of its generated UMI there, while the observed
+sepsis cells carry 0.014 % of their UMI on them.  Zeroing those genes in EVERY arm (scratch and pretrained alike) and
+rescoring compares the arms on the genes the scratch model could learn.  The unmasked scores stay the primary record.
+
+  mask_rescore.py ARM NPZ_PATH_OR_- [--held ye2026_sepsis] [--split hoL_ye2026_sepsis]
+    NPZ "-" = read the NPZ bytes from stdin (ssh spark-0110 cat ... | mask_rescore.py ARM -); its sha256 must equal the
+    receipt's output_sha256 (the receipt <npz>.log is read from the server_1 path given by --receipt).
+  The masked NPZ (+ a derived receipt with the source sha and the masked gene ids) is written to
+  generated_masked/<held>/<split>/<ARM>.npz, scored with score_ft.py exactly as score_pending.sh scores (usable samples,
+  per-cohort contrast) into scores_masked/<held>/<ARM>/, then deleted (receipt kept).
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+
+P = Path(__file__).resolve().parents[1]
+SRC = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+PY = "/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python"
+
+
+def never_trained_mask(split: str, held: str, gene_ids: np.ndarray) -> np.ndarray:
+    s = json.loads((P / f"splits/{split}.json").read_text())
+    tr = None
+    for c in s["training_cohorts"]:
+        z = np.load(Path(c["dataset_dir"]) / "cells_panel6k.npz", allow_pickle=False)
+        if not np.array_equal(z["panel_gene_ids"].astype(str), gene_ids):
+            raise SystemExit(f"{c['cohort']}: panel differs")
+        m = z["panel_measured"].any(0)
+        tr = m if tr is None else (tr | m)
+    z = np.load(SRC / f"data/{held}/cells_panel6k.npz", allow_pickle=False)
+    return z["panel_measured"].any(0) & ~tr
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("arm")
+    ap.add_argument("npz")
+    ap.add_argument("--receipt", required=True, help="generation receipt (.log JSON with output_sha256)")
+    ap.add_argument("--held", default="ye2026_sepsis")
+    ap.add_argument("--split", default="hoL_ye2026_sepsis")
+    ap.add_argument("--condition", default=None, help="local copy of the arm's condition NPZ when the receipt's path "
+                    "is not on this host (bulk-broadcast baseline); passed to score_ft.py as --condition ARM=PATH")
+    a = ap.parse_args()
+    raw = sys.stdin.buffer.read() if a.npz == "-" else Path(a.npz).read_bytes()
+    sha = hashlib.sha256(raw).hexdigest()
+    rec = json.loads(Path(a.receipt).read_text())
+    if rec.get("output_sha256") != sha:
+        raise SystemExit(f"{a.arm}: NPZ sha {sha[:12]} != receipt {str(rec.get('output_sha256'))[:12]}")
+    d = dict(np.load(io.BytesIO(raw), allow_pickle=False))
+    del raw
+    ids = d["gene_ids"].astype(str)
+    m = never_trained_mask(a.split, a.held, ids)
+    before = float(d["generated_counts"][:, m].sum() / d["generated_counts"].sum())
+    d["generated_counts"][:, m] = 0
+    out = P / f"generated_masked/{a.held}/{a.split}/{a.arm}.npz"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    np.savez(out, **d)
+    osha = hashlib.sha256(out.read_bytes()).hexdigest()
+    derived = {"output_sha256": osha, "derived_from": a.npz if a.npz != "-" else a.receipt.replace(".log", ".npz"),
+               "source_sha256": sha, "source_receipt": a.receipt, "masked_rule": "panel genes measured in the held-out "
+               "cohort but in none of the split's training cohorts set to 0 in generated_counts",
+               "masked_gene_ids": ids[m].tolist(), "n_masked": int(m.sum()),
+               "generated_umi_share_masked_before": before, "written": datetime.now().isoformat(timespec="seconds"),
+               **{k: rec.get(k) for k in ("condition_npz", "condition_sha256", "checkpoint", "checkpoint_sha256", "seed",
+                                          "steps", "support_readout", "weights") if k in rec}}
+    out.with_suffix(".log").write_text(json.dumps(derived, indent=1) + "\n")
+    cargs = subprocess.run(["bash", str(SRC / "tools/contrast_args.sh"), a.held], capture_output=True,
+                           text=True).stdout.split()
+    so = P / f"scores_masked/{a.held}/{a.arm}"
+    so.mkdir(parents=True, exist_ok=True)
+    r = subprocess.run([PY, str(SRC / "tools/score_ft.py"), "--dataset", a.held, "--threads", "8", "--donors",
+                        str(P / f"data/{a.held}/usable_samples.txt"), "--arm", f"{a.arm}={out}", *cargs, "--out", str(so),
+                        *(["--condition", f"{a.arm}={a.condition}"] if a.condition else [])],
+                       capture_output=True, text=True)
+    (so / "score.log").write_text(r.stdout + r.stderr)
+    out.unlink()
+    print(json.dumps({"arm": a.arm, "masked_genes": int(m.sum()), "generated_umi_share_masked_before": round(before, 4),
+                      "score_rc": r.returncode}))
+    return r.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/run_loco_queue.sh

@@ -0,0 +1,182 @@
+#!/usr/bin/env bash
+# Cross-cohort (LOCO) queue: the same queue file runs on server_1 and server_2; each line is one unit that a host
+# claims before it starts (atomic mkdir in claims/ on server_1, so a unit never runs on both hosts).
+#   zs|COHORT|K                      base model on data/<cohort>/test_raw_K<K>.npz   -> generated/<cohort>/zs_K<K>.npz
+#   xcal|SPLIT|K                     base model on splits/<split>/test_xcal_K<K>.npz -> generated/<held>/<split>/xcal_K<K>.npz
+#   loco|SPLIT|K|TAG|MODE|LR[|extra] fine-tune (ft_sdd_multi.py) -> runs/<split>/K<K>/<TAG>/, then sample the held-out
+#                                    cohort's test_raw_K<K>.npz -> generated/<held>/<split>/K<K>_<TAG>.npz; with --block
+#                                    (step saturation) every milestone checkpoint -> .../K<K>_<TAG>_s<step>.npz
+# Every GPU step goes through ml-run (ml.slice, shared GPU lock) after the thermal gate and gpu_usable.sh (shared with
+# the scSemiProfiler queue: when only this user's ml.slice job holds the GPU, ml-run waits on the lock, so the two
+# queues alternate and never overlap). Sampling: the sampler call of utility_studies sample_queue.sh (DDIM 50,
+# Bernoulli read-out, seed 20260927, 1,500 cells per bulk), behind this queue's gate.
+# On server_2 every finished unit is copied back to the same absolute paths on server_1 (sha-checked).
+# A host claims a unit only after its GPU gate passes. A failed unit is marked FAILED in its claim and not retried;
+# two failures in a row stop the queue.
+#   env: QUEUE (required), REVERSE (0; 1 = walk the queue from the end), MAX_WAIT_H (480)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P=$M8/plans/paired_crosscohort_20261002
+SQ=$M8/plans/utility_studies_final6k_20260925/tools/sample_queue.sh
+BASE_CKPT=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+SEED=20260927
+COORD=spark-fa6b
+case "$(hostname -s)" in
+  spark-fa6b) HOST=server_1; PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python ;;
+  spark-0110) HOST=server_2; PY=/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python ;;
+  *) echo "unknown host" >&2; exit 2 ;;
+esac
+QUEUE="${QUEUE:?QUEUE}"; REVERSE="${REVERSE:-0}"; MAX_WAIT_H="${MAX_WAIT_H:-480}"
+mkdir -p "$P/logs"
+LOG=$P/logs/loco_queue_$(basename "$QUEUE" .txt)_${HOST}_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+
+on_coord() { if [[ $HOST == server_1 ]]; then bash -c "$1"; else ssh -n "$COORD" "$1"; fi; }
+claim() {   # claim KEY -> 0 if this host now owns the unit
+  on_coord "mkdir -p '$P/claims' && mkdir '$P/claims/$1' 2>/dev/null && echo '$HOST $(date -Is)' > '$P/claims/$1/OWNER'"
+}
+mark() { on_coord "echo '$HOST $(date -Is) ${3:-}' > '$P/claims/$1/$2'"; }
+usable_or_own() {
+  # gpu_usable.sh (free GPU, or a foreign process idle at <= 5 %), or else: every compute process on the GPU is this
+  # user's own job inside ml.slice (the scSemiProfiler queue holding the shared lock). In that case ml-run below blocks
+  # on the shared lock and the two queues take turns, never overlapping. Anything else (another user's process at
+  # work, memory below 32 GiB, guard inactive) waits.
+  local r; r=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null) && { echo "$r"; return 0; }
+  systemctl --user is-active --quiet ml-memory-guard.service || return 1
+  local avail; avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo); (( avail >= 32 )) || return 1
+  local pids p; pids=$(nvidia-smi --query-compute-apps=pid --format=csv,noheader | tr -d ' ')
+  [[ -n $pids ]] || return 1
+  for p in $pids; do
+    [[ "$(stat -c %U "/proc/$p" 2>/dev/null)" == "$(id -un)" ]] && grep -q '/ml.slice/' "/proc/$p/cgroup" 2>/dev/null || return 1
+  done
+  echo "own ml.slice job on the GPU; waiting on the shared lock"
+}
+gate() {
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") && usable=$(usable_or_own); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 60
+  done
+  echo "$verdict; GPU $usable"
+}
+copy_back() {  # server_2 -> server_1, same absolute paths; NPZ checked against its receipt's sha256
+  [[ $HOST == server_1 ]] && return 0
+  local f
+  for f in "$@"; do
+    [[ -e $f ]] || continue
+    ssh -n "$COORD" "mkdir -p '$(dirname "$f")'" && rsync -a "$f" "$COORD:$(dirname "$f")/" || return 1
+  done
+  return 0
+}
+yield_gpu() {  # after each GPU step: if another of this user's GPU queues is active, pause longer than its 120 s gate
+  # poll so that it gets the next turn on the shared lock (the queues alternate instead of one starving the other)
+  local u
+  for u in $(systemctl --user list-units --type=service --state=active --no-legend 2>/dev/null | awk '{print $1}' \
+             | grep -E '^scsemi-queue'); do
+    log "yield: $u is active; pausing 150 s"; sleep 150; return 0
+  done
+}
+sample() {  # sample TAG CKPT CKPT_SHA COND OUT -- the sampler call of sample_queue.sh ($SQ), with this queue's gate
+  local tag=$1 ck=$2 sha=$3 cond=$4 out=$5 rec=${5%.npz}.log err=${5%.npz}.err
+  if [[ -s $rec && ( -s $out || -e ${out%.npz}.moved ) ]]; then log "$tag already sampled; skipped"; return 0; fi
+  [[ -s $cond ]] || { log "WARN: $tag condition missing: $cond"; return 1; }
+  [[ "$(sha256sum "$ck" | cut -d' ' -f1)" == "$sha" ]] || { log "WARN: $tag checkpoint sha differs"; return 1; }
+  mkdir -p "$(dirname "$out")"
+  log "--- sample $tag seed=$SEED ($(gate))"
+  if "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+       PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+       --checkpoint "$ck" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 \
+       --steps 50 --seed "$SEED" --device cuda --conditioner-source embedded \
+       --active-logit-threshold 0.0 --support-readout bernoulli > "$rec" 2> "$err"; then
+    log "$tag sampled: $(python3 -c "import json;d=json.load(open('$rec'));print('zero_frac %.4f' % d.get('generated_zero_fraction',-1), d.get('output_sha256','')[:12])" 2>/dev/null)"
+  else
+    log "WARN: $tag sampling failed (see $err)"; rm -f "$rec"; yield_gpu; return 1
+  fi
+  yield_gpu
+  # (2026-10-05) score_pending.sh may score and offload the NPZ to server_2 during the yield pause; a .moved marker
+  # (written only after the remote sha matched) counts as present
+  [[ -s $rec && ( -s $out || -e ${out%.npz}.moved ) ]]
+}
+held_of() { python3 -c "import json;print(json.load(open('$P/splits/$1.json'))['held_out'])"; }
+
+mapfile -t LINES < <(grep -v -e '^\s*$' -e '^#' "$QUEUE")
+[[ $REVERSE == 1 ]] && mapfile -t LINES < <(printf '%s\n' "${LINES[@]}" | tac)
+log "queue=$QUEUE host=$HOST units=${#LINES[@]} reverse=$REVERSE py=$PY"
+fails=0; n_done=0
+for line in "${LINES[@]}"; do
+  IFS='|' read -r kind a1 a2 a3 a4 a5 extra <<< "$line"
+  case $kind in
+    zs)   key="zs_${a1}_K${a2}" ;;
+    xcal) key="xcal_${a1}_K${a2}" ;;
+    loco) key="loco_${a1}_K${a2}_${a3}" ;;
+    *) log "WARN: unknown line: $line"; continue ;;
+  esac
+  # wait for a usable GPU before claiming, so a host that cannot run now never holds a unit the other host could run
+  on_coord "test -d '$P/claims/$key'" && continue
+  gate > /dev/null
+  claim "$key" || continue
+  unit_t0=$(date +%s)
+  log "=== $key claimed"
+  ok=0
+  if [[ $kind == zs ]]; then
+    out=$P/generated/$a1/zs_K$a2.npz
+    sample "$key" "$BASE_CKPT" "$BASE_SHA" "$P/data/$a1/test_raw_K$a2.npz" "$out" && ok=1
+    files=("$out" "${out%.npz}.log" "${out%.npz}.err")
+  elif [[ $kind == xcal ]]; then
+    held=$(held_of "$a1"); out=$P/generated/$held/$a1/xcal_K$a2.npz
+    sample "$key" "$BASE_CKPT" "$BASE_SHA" "$P/splits/$a1/test_xcal_K$a2.npz" "$out" && ok=1
+    files=("$out" "${out%.npz}.log" "${out%.npz}.err")
+  else
+    split=$a1 K=$a2 tag=$a3 mode=$a4 lr=$a5
+    held=$(held_of "$split"); run=$P/runs/$split/K$K/$tag; out=$P/generated/$held/$split/K${K}_$tag.npz
+    mkdir -p "$run"
+    if [[ ! -s $run/RUN.json ]]; then
+      log "--- train $split K=$K $tag mode=$mode lr=$lr ($(gate))"
+      # shellcheck disable=SC2086
+      "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+        OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$P/tools/ft_sdd_multi.py" --checkpoint "$BASE_CKPT" \
+        --checkpoint-sha "$BASE_SHA" --split "$P/splits/$split.json" --k "$K" --mode "$mode" --lr "$lr" \
+        --out-dir "$run" ${extra//|/ } >> "$run/train.log" 2>&1
+      yield_gpu
+    fi
+    files=("$run/RUN.json" "$run/history.json" "$run/train.log" "$run/checkpoint_ft.pt")
+    if [[ -s $run/RUN.json ]]; then
+      sha=$(python3 -c "import json;print(json.load(open('$run/RUN.json'))['checkpoint_sha256'])")
+      log "train $key: $(python3 -c "import json;d=json.load(open('$run/RUN.json'));print('selected step',d['selected_step'],'of',d['steps_run'],'stop',d.get('stop_reason'),'inner-val %.5f (pre %.5f)'%(d['selected_inner_val_loss'],d['pretrained_inner_val_loss']),'%.0f s'%d['wall_seconds'])")"
+      ms=$(python3 -c "import json;d=json.load(open('$run/RUN.json'));print(' '.join('%d:%s' % (m['milestone_step'], m['checkpoint_sha256']) for m in d.get('milestones') or []))")
+      if [[ -n $ms ]]; then
+        # step-saturation runs: sample every milestone checkpoint (best-so-far at each block end) -> K<K>_<tag>_s<step>
+        ok=1; files+=("$run/milestones.json")
+        for x in $ms; do
+          st=${x%%:*}; msha=${x#*:}; out=$P/generated/$held/$split/K${K}_${tag}_s${st}.npz
+          sample "${key}_s${st}" "$run/checkpoint_ft_s${st}.pt" "$msha" "$P/data/$held/test_raw_K$K.npz" "$out" || ok=0
+          files+=("$run/checkpoint_ft_s${st}.pt" "$out" "${out%.npz}.log" "${out%.npz}.err")
+        done
+      else
+        sample "$key" "$run/checkpoint_ft.pt" "$sha" "$P/data/$held/test_raw_K$K.npz" "$out" && ok=1
+        files+=("$out" "${out%.npz}.log" "${out%.npz}.err")
+      fi
+    else
+      log "WARN: train $key failed (see $run/train.log)"
+    fi
+  fi
+  if (( ok )); then
+    copy_back "${files[@]}" || { log "WARN: $key copy to server_1 failed; outputs kept on $HOST"; ok=0; }
+  fi
+  if (( ok )); then
+    mark "$key" DONE "$(python3 -c "import json;print(json.load(open('${out%.npz}.log'))['output_sha256'])")"
+    log "=== $key done"; fails=0; n_done=$((n_done+1))
+  else
+    mark "$key" FAILED; log "=== $key FAILED"; fails=$((fails+1))
+    # host policy: after a memory-guard stop, inspect before any further GPU work -> never move on to the next unit
+    if journalctl -t ml-memory-guard --since "@$unit_t0" --no-pager 2>/dev/null | grep -q "stopping ml.slice"; then
+      log "ABORT: the memory guard stopped ml.slice during $key; queue stopped for inspection (no further units)"
+      exit 1
+    fi
+    (( fails >= 2 )) && { log "ABORT: two failed units in a row"; exit 1; }
+  fi
+done
+log "queue finished on $HOST: units done here=$n_done"

paper-releases/pbisc-diffusion/updates/20261005T133325Z-deck-scratch-samepairs-tracking/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/table_masked.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""Table of the held-out arms scored after zeroing never-trained genes (scores_masked/<held>/<arm>/), next to the
+unmasked scores (scores/<held>/<arm>/).  usage: table_masked.py [HELD]   -> prints; writes scores_masked/<held>/table.csv"""
+import glob, json, os, sys
+import pandas as pd
+P = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+held = sys.argv[1] if len(sys.argv) > 1 else "ye2026_sepsis"
+rows = []
+for kind, root in (("masked", f"{P}/scores_masked/{held}"), ("unmasked", f"{P}/scores/{held}")):
+    for d in sorted(glob.glob(f"{root}/*/summary.json")):
+        arm = d.split("/")[-2]
+        if kind == "unmasked" and not os.path.exists(f"{P}/scores_masked/{held}/{arm}/summary.json"):
+            continue
+        s = json.load(open(d)); h = s["headline"][list(s["headline"])[0]]
+        c = pd.read_csv(os.path.dirname(d) + "/contrast.csv")
+        c = c[(c.statistic == "mean_cp10k") & c.celltype.isin(["T cell", "B cell", "Monocyte", "NK cell"])]
+        rows.append({"arm": arm, "scores": kind, "comp_l1": h["comp_l1"], "precision": h["precision"],
+                     "coverage": h["coverage"], "coverage_dm": h["coverage_dm"], "pb_r": h["pb_r_median"],
+                     "pb_top1": h["pb_top1"], "mono_pct": h["mono_pct_gen"], "median_umi": h["median_umi_gen"],
+                     "logfc_r": h["contrast_mean_cp10k_r_gen"], "partial_r": c.partial_r_generated_given_broadcast.mean(),
+                     "deg_top50_4type": h.get("deg_top50_sum_4type")})
+t = pd.DataFrame(rows).sort_values(["scores", "arm"])
+t.to_csv(f"{P}/scores_masked/{held}/table.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_columns", 20):
+    print(t.round(3).to_string(index=False))
+    h = s["headline"][list(s["headline"])[0]]
+    print("observed: mono %.1f%%, median UMI %.0f, broadcast logFC r %.3f, comp L1 LOO null %.3f" % (
+        h["mono_pct_obs"], h["median_umi_obs"], h["contrast_mean_cp10k_r_broadcast"], h["comp_l1_obs_loo_null"]))