Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/README.md

@@ -0,0 +1,241 @@
+# PBISC-Diffusion paper summary deck (2026-09-30, r00; ordered by the six manuscript figures since 2026-10-06)
+
+64-slide English deck, ordered by the six main figures of the Nature-style manuscript plan (user request 2026-10-06,
+following `paper-release-20260928/reference-papers/Nature Style Manuscript Writing.pdf`):
+- Title and outline: 6 figures, Supplementary, Appendix, Discussion.
+- "Manuscript plan: six main figures": a table of each figure's claim and how many panels are ready.
+- For each figure:
+  - a divider;
+  - a plan slide, a table of panel / content / evidence slide / status (Ready, Adapt, Draft, Build, Run, Plan);
+  - the existing slides that serve its panels, each labelled "Fig. 2c" etc. in the top-right corner.
+- Supplementary: a plan slide plus the from-scratch results. Appendix: the modified scSemiProfiler run. Discussion: the
+  other-tissues outlook.
+
+User decisions of 2026-10-06:
+- No PBISC-VAE: scSemiProfiler, a VAE-based method, is the comparison (Fig. 3).
+- Fig. 2 shows LoRA first on the healthy cohort (ImMicro) with the realism metrics (precision, coverage, classifier
+  AUROC, MMD, E_N); the disease-cohort comparison comes later.
+- CYBERSORTx and other bulk deconvolution methods go to the Supplementary only (PBISC generates single cells).
+- Figs 4 and 6 stay unplanned. Their existing slides are kept in the section as "Fig. 4 candidate" / "Fig. 6 candidate".
+
+Only order, section labels, the agenda and new plan or draft slides changed. The new slides are "Overview draft (Nature
+style)", the manuscript's candidate Fig. 1, and "Pretraining corpus", the Fig. 1d strip. No new result figures were
+made.
+- The plan lives in `data/figure_plan.json`.
+- `tools/figure_plan.py` draws the plan tables and the slide text, and checks that every slide is placed exactly once.
+- `tools/restructure_figure_order_20261006.py` rebuilds the order from the plan. It is rerun after every plan change and
+  keeps all slide fields.
+- The earlier section order (10 sections, 45 slides) is in `_archive/2026-10-06_before_figure_order/`.
+
+Short keyword lines only; the figures carry the results. Every slide that uses a published method, metric or
+baseline has a one-line "References:" footer; full citations are in the speaker notes.
+
+- `PBISC-Diffusion_paper_summary_20260930.pptx`: the deck
+- `PBISC-Diffusion_paper_summary_20260930.pdf`: LibreOffice PDF of the deck
+- `data/slides_spec.json`: slide order, titles, keywords, footnotes, references, speaker-note text
+- `generate_deck.py`: builds the pptx from `data/slides_spec.json` only (python-pptx)
+- `figures/`: exactly the figures the slides show (PNG + PDF), made by `tools/sec*.py`. Intermediate panels go to a
+  temporary folder; superseded figures are deleted, not kept (2026-10-02, user request; every deleted file was
+  checked to be in the paper archive by sha256 first).
+- `data/sec*.csv` and `data/*_slide_text.json`: every plotted or quoted number with its source path
+- `render/`: PDF and 70-dpi slide JPGs for checking
+
+## Slide order
+
+| section | slides |
+|---|---|
+| 1 Model overview | bulk in, cells out; denoiser |
+| 2 Backbone | SDD → PBISC-Diffusion; bulk conditioning |
+| 3 Architecture ablation | width & context (loss, benchmark); gene panel |
+| 4 Metrics + SLE benchmark | **how we score generated cells** (metric table with references); SLE benchmark; per cell type; bulk broadcast baseline |
+| 5 Real bulk vs pseudobulk | input shift; same shift in three cohorts; cells off-manifold; disease direction flips |
+| 6 Paired fine-tuning | method; evaluation design |
+| 7 LoRA ablations | full vs LoRA vs cond.-encoder-only; LoRA rank r = 4 / 16 / 64; K diversification |
+| 8 Pairs needed | composition / coverage / steps (with scSemiProfiler at the same n); donor and disease signal; pairs from other cohorts; longer training on them (with training minutes) |
+| 9 Paired validation | cohorts; 5 donors: cells, realism beyond P/C, P/C at k = 3 / 5 / 10, scSemiProfiler copies its representative, disease signal, CAT curves, time to apply; 5-fold CV (with scSemiProfiler on the same pairs); same training pairs: LoRA vs scSemiProfiler; 5-fold realism metrics |
+| 10 Next steps | paired-subset cohorts (planned); other tissues from a few dozen pairs (Discussion framing of the from-scratch results) |
+| Supplementary | no pretraining: same cohort, from scratch (pilot); no pretraining: other cohorts, from scratch (pilot); rare states: from scratch vs pretrained; deconvolution with the same pairs: composition; deconvolution with the same pairs: disease signal |
+| Appendix | scSemiProfiler without its output threshold (sensitivity; modified read-out, not the official output) |
+
+## Rebuild
+
+Everything is CPU only; no GPU or checkpoint is touched.
+
+```bash
+# prerequisites (plan folder plans/paired_finetune_intradataset_20260927/, CPU):
+#   scsemi/tools/representative_dependence.py      -> scsemi/analysis/representative_dependence_20261002/
+#   tools/contrast_extra.py (+ tools/contrast_extra_tables.py) -> scores_contrast/   (Spearman, ceiling, limma, CAT, RBO)
+#   tools/build_tpm_zeroshot.py + tools/score_tpm_zeroshot.sh -> scores/<ds>/zeroshot_tpm_20261002/pooled/
+#     (the length-corrected zero-shot arm needs one GPU sampling step: tools/sample_lockwait.sh, coordinator only)
+cd /home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00
+# shared helpers, not run directly: style.py, sec03_common.py, scsemi_results.py, fold_sizes.py
+for f in sec01_overview sec02_backbone sec03_width_loss sec03_width_bench sec03_panel \
+         sec04_metrics_overview sec04_sle_benchmark sec05_condition_space sec05_cells_offmanifold \
+         sec05_behcet_direction sec05_shift_cohorts sec06_finetune_method sec07_ft_modes \
+         sec07_k_aug sec07_rank_sweep sec08_pairs_needed sec08_cross_cohort sec09_paired_validation sec09_extra_metrics \
+         sec09_time_to_apply sec09_scsemi_representative sec09_cat_curves sec10_paired_subset_cohorts \
+         secA_scsemi_readout sec07_no_pretraining sec08_cross_scratch sec09_same_pairs \
+         secS_scratch_rare_states secS_deconvolution sec10_other_tissues figure_plan; do   # keep this order (sec10 reads secS; figure_plan last)
+  python3 "tools/$f.py" || break
+done
+python3 tools/restructure_figure_order_20261006.py   # order the slides by data/figure_plan.json
+python3 tools/sync_sec09_text.py      # copy every generated slide text (sec09_index / text_source) into the spec
+python3 generate_deck.py              # -> PBISC-Diffusion_paper_summary_20260930.pptx
+soffice --headless --convert-to pdf --outdir render PBISC-Diffusion_paper_summary_20260930.pptx
+pdftoppm -jpeg -r 70 render/PBISC-Diffusion_paper_summary_20260930.pdf render/slide
+cp render/PBISC-Diffusion_paper_summary_20260930.pdf .
+```
+
+`generate_deck.py` stops with an error if a figure is missing, a title does not fit on one line, a footnote needs
+more than 2 lines (1 line when the slide has references), the reference line needs more than 1 line, or any text
+contains Korean or placeholder words. `tools/restructure_20261002.py` is the one-off script that produced the current
+slide order and the references (it refuses to run twice).
+
+## Notes
+
+- **No "all" label (2026-10-02).** The 5-fold arm trains each fold model on the other four folds minus 7–8
+  inner-validation donors; its test fold is never trained on (RUN.json `test_rows_never_loaded_for_training`). Figures
+  label it "5-fold CV (other 4 folds)" and learning-curve ticks show the training-pair count per fold (78–79 ImMicro,
+  58–59 sepsis), read by `tools/fold_sizes.py`.
+- **Learning curve x = 0 uses no pairs (2026-10-02).** It shows the zero-shot model fed the real bulk as measured
+  and after exon-length correction (counts / Ensembl union-exon kb, then the same fixed-depth arithmetic;
+  `plans/.../tools/build_tpm_zeroshot.py`, scored in `scores/<ds>/zeroshot_tpm_20261002/pooled`). The old x = 0
+  calibration point, whose alpha used every training pair of the fold, is gone; calibration appears only fitted on the
+  same n pairs as the LoRA point (squares; `cal_budget_20261001`).
+- **Disease metrics (2026-10-02).** Next to Pearson logFC r and the Welch top-50 DEG overlap: Spearman r, the
+  split-half ceiling (observed vs observed, Spearman–Brown), limma-voom top-50 DEG, each arm's chance overlap, and
+  CAT curves with the k / 2G chance line (`plans/.../scores_contrast/`, tools/contrast_extra.py; every Pearson r and
+  Welch count reproduced exactly). Repeated samples of one patient (Imperial, Giroux, Ji) count as separate samples in
+  both DE tests, as in the scorer (footnote).
+- Section 9 text is generated: `tools/sec09_paired_validation.py`, `sec09_extra_metrics.py`, `sec07_rank_sweep.py`,
+  `sec09_time_to_apply.py`, `sec09_scsemi_representative.py`, `sec09_cat_curves.py` write slide text JSON; sync copies
+  it. Hand-written: the keywords of the two "Pairs needed" slides (section 8) and of every slide in sections 1–7 and 10.
+- Giroux's disease metrics exclude 196 sex-linked genes (severity is confounded with sex), from
+  `plans/.../scores_nosex/`. The calibration comparator is "Zero-shot + calibration" (user decision 2026-10-01).
+- Story rule (user decision 2026-09-30): no PBISC-VAE and no reference calibration (refcal). The exon-length-corrected
+  input is used only as the no-pair x = 0 point of the learning curve (user decision 2026-10-02).
+  `tools/sec04_immicro.py` (refcal vs scSemiProfiler on ImMicro) is kept but is not part of the deck or the rebuild.
+- scSemiProfiler 5-fold and equal-budget results are picked up automatically when they appear (`tools/scsemi_results.py`;
+  arm `scsemi__raw` in `scores/<cohort>/scsemi_cv_20261002/pooled*/`, `scsemi_n{5,10,20,40}__raw` in
+  `scores/<cohort>/scsemi_budget_20261002/pooled*/`; same donors and reference cells as the main pooled call only).
+  Then rerun sections 8 and 9, sync, recheck the section 8 keywords and rebuild.
+- Earlier versions: `_archive/2026-09-30_before_no_vae_refcal/`, `_archive/2026-10-01_before_extra_metrics/`,
+  `_archive/2026-10-02_before_time_to_apply/`, `_archive/2026-10-02_before_restructure/` (pptx, PDF, spec; their
+  figures are in the paper archive). `DRAFT_1150_*`: the copy shown at the 2026-09-30 12:00 meeting.
+
+- Added 2026-10-03 (user decision: the cross-cohort experiment is reported at K = 1000 only and is the figure that explains
+  why PBISC fits LoRA on a few pairs of each cohort): slides 25-26 in section 8, `tools/sec08_cross_cohort.py`.
+  - Slide 25 "Pairs from other cohorts do not transfer": per held-out cohort, composition L1 / coverage / disease logFC r of
+    zero-shot, calibration fitted on the other cohorts, LoRA r16 / r64 / full fine-tune trained on the other cohorts
+    (+ Liu 2021) at step saturation, and LoRA on the cohort's own pairs (5-fold pooled).
+  - Slide 26 "Longer training on other cohorts" (": gap stays" since 2026-10-06): the same metrics at every 20k-step
+    milestone.
+  - Source plan: `plans/paired_crosscohort_20261002/` (README; same-reference and same-sample checks in the script).
+    Agenda item 8 now reads "How many pairs, and do other cohorts' pairs transfer". The deck has 37 slides.
+    Pre-update copy: `_archive/2026-10-03_before_cross_cohort/`.
+
+## Sources
+
+Final model: `runs/f01_6k_1x_seed20260627` (epoch 16, EMA). Scores and receipts come from
+`plans/utility_studies_final6k_20260925/`, `plans/paired_finetune_intradataset_20260927/`,
+`plans/immicro_scsemi_comparison_20260927/`, `plans/floor01_campaign_20260923/`,
+`analysis/scsemi_benchmark_diffusion_20260913/` and the run folders named in each `data/sec*.csv`. Reference PDFs:
+`/home/sj_server_1/PBISC/paper-release-20260928/reference-papers/` (INDEX.md). Manuscript:
+`/home/sj_server_1/PBISC/paper-release-20260928/manuscript/`.
+- 2026-10-04 appendix (user decision: supplementary, appendix only, because it changes scSemiProfiler's official
+  output). Slide 38 is the divider "Appendix" and slide 39 is "Appendix: scSemiProfiler without output threshold"
+  (`tools/secA_scsemi_readout.py`, `data/secA_scsemi_readout{.csv,_slide_text.json}`).
+  - Inputs: `plans/paired_finetune_intradataset_20260927/scsemi/analysis/output_variants_20261003/`. The script checks
+    that its LoRA-5 and official scSemiProfiler values equal the section 9 slide data draw by draw.
+  - Result: without upstream's output threshold, scSemiProfiler's coverage rises in 5/5 cohorts, and 23/23 LoRA-5
+    comparisons (coverage, precision, composition, logFC r, DEG) keep their winner.
+  - The outline keeps its 10 sections (the builder requires 10). The pre-change copy is in
+    `_archive/2026-10-04_before_appendix/`. The deck has 39 slides.
+- 2026-10-05 update (user request: put the results so far into the deck). Pre-change copy: `_archive/2026-10-05_before_scratch_cv/`.
+  - New slide 23, "No pretraining: same cohort, from scratch" (`tools/sec07_no_pretraining.py`). Pilot on sepsis fold 0
+    (17 donors). Reads `fold0_scratch_20261005/` and the runs' RUN.json. The donor composition r is recomputed from
+    per_donor.csv and reproduces ablation_extra_donor.csv.
+  - New slide 28, "No pretraining: other cohorts, from scratch" (`tools/sec08_cross_scratch.py`). Held-out sepsis pilot.
+    Every arm is read from `paired_crosscohort_20261002/scores_masked/`: genes no training cohort measured are zeroed
+    in all arms, because the unmasked scratch arm puts 91–94 % of its UMI there (read from the generated_masked logs
+    since 2026-10-06).
+  - New slide 38, "Same training pairs: LoRA vs scSemiProfiler" (`tools/sec09_same_pairs.py`). scSemiProfiler 5-fold
+    CV with LoRA's own training pairs, plus GPU hours per fold from the receipts on either host. Cohorts that are still
+    running show "in progress"; rerun the script as they finish.
+  - These two slides now draw the scSemiProfiler CV / budget runs automatically:
+    - Slide 24, "Pairs needed" (diamonds; ImMicro so far): keyword 2 reworded, footnote extended.
+    - Slide 37, "5-fold CV" (yellow bar; ImMicro and Ji so far).
+  - `tools/sec09_paired_validation.py` reads the scSemiProfiler CV arm's Spearman / limma values from
+    `scores_contrast/<cohort>/scsemi_cv_20261002/pooled/` (contrast_extra.py --design scored). Pearson r and the Welch
+    DEG must match the scorer; the values stay blank until computed. Cohorts not yet run say "in progress".
+  - Agenda item 7 now reads "LoRA: compute, rank, K; training from scratch". The deck has 42 slides.
+  - New helper: `tools/grouped_bars.py`.
+- 2026-10-06 update (user request: check that the cross-cohort LoRA / full FT, cross-cohort from-scratch and
+  same-cohort from-scratch (+ recipes) results, with benchmarks and training times, and the scratch-vs-pretrained rare
+  states are in the deck; user decision: the from-scratch results go to the paper's Supplementary and the Discussion
+  presents them as a route to other tissues). Pre-change copy: `_archive/2026-10-06_before_supplementary/`.
+  - **Supplementary block (new divider, slides 40-43).**
+    - "No pretraining: same cohort, from scratch" and "No pretraining: other cohorts, from scratch" moved here from
+      sections 7 and 8. Their content is unchanged; slide 42's notes now name the cross-cohort slides by title.
+    - New "Rare states: from scratch vs pretrained" (`tools/secS_scratch_rare_states.py`).
+      - It reads the rare-state screen (`plans/rare_states_screen_20261004/out/sepsis_fold0_*` and
+        `sepsis_loco_masked_*`).
+      - The cross-cohort arms use the masked scoring (46 never-measured genes zeroed in every arm).
+      - The donor bootstrap reproduces the verified analysis in `out/scratch_vs_lora_20261005/REPORT.md`.
+  - **Section 10 "Next steps".**
+    - New "Next: other tissues from a few dozen pairs" (`tools/sec10_other_tissues.py`): a comparison table, pretrained
+      + LoRA vs from scratch.
+    - Every value is read from the deck's own source tables. The say text is the user's Discussion framing.
+  - **Slide 26 "Longer training on other cohorts".** The first keyword is now training minutes to saturation (RUN.json
+    wall seconds), with per-cohort minutes and steps in the notes (`tools/sec08_cross_cohort.py`).
+  - **Slide 34 "5 donors: time to apply".**
+    - The pretraining hours are read from `data/sec06_ft_method.csv`, no longer hard-coded.
+    - The note names the 'Fine-tuning with paired bulk + sc' slide by title. Its old "slide 15" pointed at the wrong
+      slide.
+  - Agenda items 7 and 10 updated. Spec change: `tools/restructure_20261006.py` (refuses to run twice). The deck has 45
+    slides; no Korean text.
+  - **Review pass (same day).** An independent 5-agent review of the changed slides confirmed 39 issues; all are
+    fixed. Pre-review copies of the touched scripts and the spec: `_archive/2026-10-06_before_supplementary/*.pre_review`.
+    - Slide 39: pretraining now reads 33.1 M train cells (`train_split_cells`; the 41.4 M corpus includes val/test).
+      The rare-state row follows the bootstrap verdicts on both sides (closer on ISG-high T / on DN2 B; labels and
+      states both arms miss by > 4-fold are not counted). "No corpus" became "come close": the scratch runs still took
+      the panel, value scaler and z-score constants from the PBMC checkpoint (RUN.json `kept_from_checkpoint`, now in
+      the notes). The say text carries the one-fold pilot qualifier; the footnote names both pilots.
+    - Slide 43: "no significant difference on average" (not "no difference"). Keyword 2 is the cycling T/NK count
+      (8 of 8 comparisons). The notes add the ISG-high T split by panel, the scratch-closer states (DN2 B, MS1), the
+      52-call tally, the fold-0 caveat (fold 0 is the own-pair LoRA's best fold for C1Q-high and cycling T/NK,
+      computed from `folds.csv`), label states unthinned, and "8 of 13 states shown".
+    - Slide 26: title "...: gap stays" and "drifts in Sepsis and Ji" are computed from the milestones (gap = no milestone
+      reaches the own-cohort coverage; drift = full fine-tune L1 up by >= 0.05). Minutes are in
+      `data/sec08_cross_cohort.csv` (wall_seconds, minutes, run_receipt) and in the numbers list.
+    - Slide 42: UMI share (94 %, 91–94 % across milestones), the observed share (0.014 %, from `cells_panel6k.npz`)
+      and both arms' stopping settings are read from the receipts; the "none" label sits inside the axes.
+    - Slide 34: keywords use the cohort means of the figure (17–59×, 57 min–4.1 h); the per-draw range 11–63× is in the
+      notes. The right panel shares the bars' rows and has a title.
+    - Talk text and pointers: slides 23, 25, 26, 45 (say), 22 (recipes description), 32 and 36 (slide pointers by
+      title), slide 1 subtitle "updated 2026-10-06".
+- 2026-10-08 update (user request: put the BayesPrism, CIBERSORTx and scSemiProfiler 5-fold results into the deck).
+  Pre-change copy: `_archive/2026-10-08_before_deconvolution/`.
+  - **Two new Supplementary slides** (`tools/secS_deconvolution.py`, `data/secS_deconvolution{.csv,_slide_text.json}`):
+    "Deconvolution with the same pairs: composition" and "...: disease signal".
+    - Source: `plans/bayesprism_paired_20261006/` (README, `results/RESULTS_full.md`, `RESULTS_cibersortx.md`).
+    - BayesPrism (recommended genes) and official CIBERSORTx (Fractions S-mode + HiRes) use the same paired donors
+      as the reference and the test samples' real bulk as the mixture, with the benchmark's own truth and scorer.
+    - Keywords and notes are computed from the tables.
+  - **Supplementary plan.** The planned "Bulk deconvolution methods" row is replaced by the two Ready slides.
+    `tools/figure_plan.py` now takes an optional per-slide note (`supplementary.notes`) and drops "Planned:" when
+    nothing is planned.
+  - **New scSemiProfiler results picked up (server_1):**
+    - Sepsis and Giroux 5-fold CV. Giroux was finalized on server_1 from sha-checked copies of its fold NPZs, and
+      rescored without sex-linked genes in `scores_nosex/giroux2022/scsemi_cv_20261002/pooled`.
+    - Sepsis equal-budget n = 5/10/20/40.
+    - Spearman/limma extras for sepsis and Giroux; realism extras for ImMicro, sepsis, Ji and Giroux.
+    - Imperial 5-fold is still running on server_2.
+  - **Text changes from the new results:**
+    - "Same training pairs": keywords are data-driven. LoRA leads on coverage and precision in 4/4 cohorts;
+      composition 3/4 and logFC r 2/3, where scSemiProfiler leads in Giroux. The GPU-time ratio is 19–62×.
+    - sec09_same_pairs.py now reads the sepsis fold-0 pilot queue tag (`sep_f0`). For Giroux it quotes DEG from
+      scores_nosex, and for older pooled LoRA calls from pooled_deg.
+    - "5-fold CV" keyword: logFC r 3/4.
+    - "Pairs needed" (hand-written): scSemiProfiler coverage 0.04 / 0.10. On sepsis disease logFC r,
+      scSemiProfiler at 5–40 pairs (0.52–0.58) is above LoRA (0.29–0.48), while its top-50 DEG stays at 2–6.

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/figure_plan.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Six-figure plan slides for the paper-summary deck (2026-10-06, Nature-style manuscript order).
+
+Reads data/figure_plan.json (the hand-written plan: figures, panels, evidence slides, status) and the current spec.
+Checks that every evidence title is a slide of the deck (or one of the two slides made here) and that every content
+slide of the deck is placed exactly once (a panel, a figure's details, Supplementary or Appendix).
+Writes:
+  figures/figplan_overview.png, figures/figplan_fig{1..6}.png   plan tables (no data)
+  figures/fig1b_overview_nature.png, figures/fig1d_corpus.png    copies of the manuscript candidates
+  data/figure_plan_slide_text.json                               slide text (synced into the spec)
+CPU only.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import textwrap
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import FancyBboxPatch  # noqa: E402
+
+DECK = Path(__file__).resolve().parents[1]
+MS = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+PLAN = DECK / "data" / "figure_plan.json"
+SPEC = DECK / "data" / "slides_spec.json"
+FIG = DECK / "figures"
+NEW = {"Overview draft (Nature style)": MS / "figures" / "fig01_architecture_nature.png",
+       "Pretraining corpus": MS / "figures" / "fig01_corpus_nature.png"}
+STATUS_COLOR = {"Ready": "#5E8C6A", "Adapt": "#C98A4B", "Draft": "#8E6C9E", "Build": "#3F6E9E", "Run": "#B5544F",
+                "Plan": "#8C8C8C"}
+INK, SUB = "#1A1A1A", "#5A5A5A"
+plt.rcParams.update({"font.family": "Arial", "font.size": 11})
+
+
+def chip(ax, x, y, s, w=0.085, h=0.05, color=None):
+    ax.add_patch(FancyBboxPatch((x, y - h / 2), w, h, boxstyle="round,pad=0.004,rounding_size=0.012",
+                                fc=color or STATUS_COLOR[s], ec="none", transform=ax.transAxes))
+    ax.text(x + w / 2, y, s, ha="center", va="center", color="white", fontsize=10, fontweight="bold",
+            transform=ax.transAxes)
+
+
+def plan_rows(fig_plan):
+    """panel rows; a figure without panels shows one row holding the slides kept in its section"""
+    if fig_plan["panels"]:
+        return fig_plan["panels"]
+    return [{"p": "", "content": "No panels planned yet", "evidence": fig_plan.get("candidates", []),
+             "status": "Plan", "note": "slides kept in this section until then" if fig_plan.get("candidates") else ""}]
+
+
+def plan_table(fig_plan, out):
+    rows = plan_rows(fig_plan)
+    cols = {"p": 0.012, "c": 0.045, "e": 0.355, "s": 0.695, "n": 0.79}
+    wrapped = []
+    for r in rows:
+        ev = "; ".join(f"\u201c{e}\u201d" for e in r["evidence"]) if r["evidence"] else "\u2014"
+        wrapped.append((textwrap.wrap(r["content"], 40), textwrap.wrap(ev, 46) or ["\u2014"],
+                        textwrap.wrap(r.get("note", ""), 30)))
+    nlines = [max(len(c), len(e), len(n), 1) for c, e, n in wrapped]
+    line_in, pad_in = 0.235, 0.09
+    fig_h = 0.45 + sum(nl * line_in + 2 * pad_in for nl in nlines)
+    fig = plt.figure(figsize=(12.3, fig_h))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.axis("off")
+    f = lambda inch: inch / fig_h  # inches -> axes fraction (vertical)
+    y = 1 - f(0.2)
+    for k, h in zip(cols, ["", "Panel content", "Evidence in this deck (slide title)", "Status", "Note"]):
+        ax.text(cols[k], y, h, fontsize=10.5, color=SUB, fontweight="bold", va="center", transform=ax.transAxes)
+    y -= f(0.25)
+    for k, (r, (c, e, n), nl) in enumerate(zip(rows, wrapped, nlines)):
+        hgt = f(nl * line_in + 2 * pad_in)
+        if k % 2 == 0:
+            ax.add_patch(plt.Rectangle((0, y - hgt), 1, hgt, color="#F4F4F4", transform=ax.transAxes, zorder=0))
+        y0 = y - f(pad_in + line_in / 2)
+        ax.text(cols["p"] + 0.008, y0, r["p"], fontsize=12, fontweight="bold", va="center", transform=ax.transAxes)
+        for x, lines, col in ((cols["c"], c, INK), (cols["e"], e, SUB), (cols["n"], n, SUB)):
+            for j, ln in enumerate(lines):
+                ax.text(x, y0 - f(j * line_in), ln, fontsize=10.5, color=col, va="center", transform=ax.transAxes)
+        chip(ax, cols["s"], y0, r["status"], w=0.075, h=f(0.2))
+        y -= hgt
+    fig.savefig(out, dpi=200)
+    plt.close(fig)
+
+
+def overview_table(plan, out):
+    figs = plan["figures"]
+    fig = plt.figure(figsize=(12.3, 5.0))
+    ax = fig.add_axes([0, 0, 1, 1])
+    ax.axis("off")
+    for x, h in ((0.012, "Main figure"), (0.40, "What the figure shows"), (0.735, "Panels by status")):
+        ax.text(x, 0.95, h, fontsize=11, color=SUB, fontweight="bold", transform=ax.transAxes)
+    step = 0.145
+    for k, fg in enumerate(figs):
+        y = 0.85 - k * step
+        if k % 2 == 0:
+            ax.add_patch(plt.Rectangle((0, y - step / 2), 1, step, color="#F4F4F4", transform=ax.transAxes, zorder=0))
+        ax.text(0.012, y, f"Fig. {fg['n']}", fontsize=12, fontweight="bold", va="center", transform=ax.transAxes)
+        ax.text(0.075, y, fg["title"], fontsize=11.5, va="center", transform=ax.transAxes)
+        lines = textwrap.wrap(fg["claim"], 50)
+        for j, ln in enumerate(lines):
+            ax.text(0.40, y + 0.022 * (len(lines) - 1) - j * 0.044, ln, fontsize=10.5, color=SUB, va="center",
+                    transform=ax.transAxes)
+        counts = {}
+        for pnl in plan_rows(fg):
+            counts[pnl["status"]] = counts.get(pnl["status"], 0) + 1
+        x = 0.735
+        if not fg["panels"]:
+            chip(ax, x, y, "Not planned", w=0.1, h=0.06, color=STATUS_COLOR["Plan"])
+            continue
+        for st in STATUS_COLOR:
+            if st in counts:
+                chip(ax, x, y, f"{st} {counts[st]}", w=0.072, h=0.06, color=STATUS_COLOR[st])
+                x += 0.084
+    fig.savefig(out, dpi=200)
+    plt.close(fig)
+
+
+def main() -> int:
+    plan = json.loads(PLAN.read_text())
+    spec = json.loads(SPEC.read_text())
+    have = [s["title"] for s in spec["slides"] if s.get("kind") == "content"]
+    have = [t for t in have if t not in NEW and not t.startswith(("Figure ", "Manuscript plan", "Supplementary plan"))]
+    placed = []
+    for f in plan["figures"]:
+        for p in f["panels"]:
+            placed += p["evidence"]
+        placed += f.get("candidates", []) + f["details"]
+    placed += plan["supplementary"]["slides"] + plan["appendix"] + plan.get("discussion", [])
+    unknown = [t for t in placed if t not in have and t not in NEW]
+    missing = [t for t in have if t not in placed]
+    twice = sorted({t for t in placed if placed.count(t) > 1})
+    if unknown or missing or twice:
+        raise SystemExit(f"plan does not match the deck: unknown {unknown}, unplaced {missing}, twice {twice}")
+    for title, src in NEW.items():
+        if not src.is_file():
+            raise SystemExit(f"missing manuscript figure {src}")
+    shutil.copyfile(NEW["Overview draft (Nature style)"], FIG / "fig1b_overview_nature.png")
+    shutil.copyfile(NEW["Pretraining corpus"], FIG / "fig1d_corpus.png")
+    overview_table(plan, FIG / "figplan_overview.png")
+    for f in plan["figures"]:
+        plan_table(f, FIG / f"figplan_fig{f['n']}.png")
+    notes = plan["supplementary"].get("notes", {})          # optional per-slide note (e.g. why it is supplementary)
+    sup = {"panels": [{"p": "S", "content": t, "evidence": [t], "status": "Ready", "note": notes.get(t, "")}
+                      for t in plan["supplementary"]["slides"]]
+           + plan["supplementary"]["planned"]
+           + [{"p": "A", "content": t, "evidence": [t], "status": "Ready", "note": "modified baseline run"}
+              for t in plan["appendix"]]}
+    plan_table(sup, FIG / "figplan_supp.png")
+
+    summ = json.loads((MS / "source_data/corpus/corpus_summary.json").read_text())
+    tot = summ["cells"]
+    healthy = summ["family_cells"]["Healthy"] / tot
+    vitro = summ["handling_cells"]["in vitro"] / tot
+    slides = [{
+        "title": "Manuscript plan: six main figures", "layout": "full",
+        "figures": [str(FIG / "figplan_overview.png")], "keywords": [],
+        "footnote_short": "Nature style: short abstract and introduction, descriptive results, short discussion, "
+                          "detailed methods; up to 17 supplementary figures.",
+        "footnote": plan["source"] + " Status: " + "; ".join(f"{k} = {v}" for k, v in plan["status_legend"].items()) + ".",
+        "numbers": []}]
+    for f in plan["figures"]:
+        n_ok = sum(p["status"] == "Ready" for p in f["panels"])
+        short = (f"{f['claim']} {n_ok} of {len(f['panels'])} panels ready." if f["panels"] else f["claim"])
+        slides.append({
+            "title": f"Figure {f['n']} plan: {f['title']}", "layout": "full",
+            "figures": [str(FIG / f"figplan_fig{f['n']}.png")], "keywords": [],
+            "footnote_short": short,
+            "footnote": "Panels: " + " ".join(f"{p['p']}) {p['content']} [{p['status']}"
+                                              + (f"; {p['note']}" if p.get("note") else "") + "]." for p in f["panels"])
+                        + (" Slides kept in this section until it is planned: " + "; ".join(f["candidates"]) + "."
+                           if f.get("candidates") else "")
+                        + (" Details in this section: " + "; ".join(f["details"]) + "." if f["details"] else ""),
+            "numbers": []})
+    slides.append({
+        "title": "Supplementary plan", "layout": "full", "figures": [str(FIG / "figplan_supp.png")], "keywords": [],
+        "footnote_short": "Bulk deconvolution methods appear here only: PBISC generates single cells, a different task.",
+        "footnote": "Supplementary: " + "; ".join(plan["supplementary"]["slides"]) + "."
+                    + (" Planned: " + "; ".join(f"{p['content']} [{p['status']}; {p.get('note', '')}]"
+                                                for p in plan["supplementary"]["planned"]) + "."
+                       if plan["supplementary"]["planned"] else "")
+                    + " Appendix: " + "; ".join(plan["appendix"]) + ".",
+        "numbers": []})
+    slides.append({
+        "title": "Overview draft (Nature style)", "layout": "full",
+        "figures": [str(FIG / "fig1b_overview_nature.png")],
+        "keywords": ["Each cell is learned with its own bulk", "Diffusion on each gene's value and detection",
+                     "One bulk in, K cells out; optional LoRA"],
+        "footnote_short": "Draft for Fig. 1b; schematic, no data. Plan: manuscript editorial/fig1_nature_redesign_plan.",
+        "footnote": "Candidate replacement for the engineering diagram (kept in this section as details and for Methods). "
+                    "Source: paper-release-20260928/manuscript/figures/fig01_architecture_nature.svg "
+                    "(scripts/build_figure1_architecture_nature.py).",
+        "numbers": []})
+    slides.append({
+        "title": "Pretraining corpus", "layout": "full",
+        "figures": [str(FIG / "fig1d_corpus.png")],
+        "keywords": [f"{tot / 1e6:.1f} M cells, {summ['datasets']} datasets, {summ['donors']:,} donors",
+                     f"{100 * healthy:.1f}% healthy donors; {100 * vitro:.1f}% cultured in vitro",
+                     "Labels describe the corpus; never model input"],
+        "footnote_short": "Detailed version: Supplementary Fig. S1 of the manuscript.",
+        "footnote": "Source: paper-release-20260928/manuscript/source_data/corpus/ (build_corpus_tables.py) and "
+                    "figures/fig01_corpus_nature.png (build_figure1_corpus.py).",
+        "numbers": [{"value": f"{tot:,} cells; {summ['datasets']} datasets; {summ['donors']:,} donors; "
+                              f"healthy {100 * healthy:.1f}%; in vitro {100 * vitro:.1f}%",
+                     "source": "manuscript/source_data/corpus/corpus_summary.json"}]})
+    out = {"section": "figure-plan", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/figure_plan.py (rerun to refresh; do not edit by hand)", "slides": slides}
+    (DECK / "data" / "figure_plan_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("placed", len(placed), "slides; plan slides", len(slides))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/restructure_figure_order_20261006.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Order the deck by the six main figures of the Nature-style manuscript plan (2026-10-06; rerun after every plan
+change).
+
+Reads data/figure_plan.json (written by hand) and data/figure_plan_slide_text.json (tools/figure_plan.py) and
+rebuilds the order of data/slides_spec.json from the slides it already holds:
+  title, agenda (6 figures + Supplementary + Appendix + Discussion), the manuscript plan,
+  for each figure: a divider, its plan slide, its panel slides in panel order (section label "Fig. 1a" ...), the
+  slides kept in the section until it is planned ("Fig. 4 candidate") and its details,
+  Supplementary (plan slide + slides), Appendix, Discussion.
+Existing slides keep every field except order and section label; dividers and plan slides are rebuilt each run.
+The text of the plan slides is filled by tools/sync_sec09_text.py.
+"""
+import json
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = DECK / "data" / "slides_spec.json"
+PLAN = DECK / "data" / "figure_plan.json"
+TEXT = "data/figure_plan_slide_text.json"
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    plan = json.loads(PLAN.read_text())
+    gen = json.loads((DECK / TEXT).read_text())["slides"]
+    made = {g["title"]: i for i, g in enumerate(gen)}
+    old = {s["title"]: s for s in spec["slides"]
+           if s.get("kind") == "content" and s.get("text_source", {}).get("file") != TEXT}
+    title = next(s for s in spec["slides"] if s.get("kind") == "title")
+    agenda = next(s for s in spec["slides"] if s.get("kind") == "agenda")
+
+    def plan_slide(t, label):
+        i = made[t]
+        g = gen[i]
+        src = "tools/figure_plan.py; data/figure_plan.json"
+        if t == "Overview draft (Nature style)":
+            src = "tools/figure_plan.py; manuscript figures/fig01_architecture_nature.svg"
+        elif t == "Pretraining corpus":
+            src = "tools/figure_plan.py; manuscript figures/fig01_corpus_nature.png, source_data/corpus/"
+        return {"kind": "content", "section": "plan", "section_label": label,
+                "text_source": {"file": TEXT, "index": i}, "title": g["title"], "layout": g["layout"],
+                "figures": [str(Path(f).relative_to(DECK)) for f in g["figures"]], "keywords": [], "footnote": "",
+                "sources": src}
+
+    def take(t, label, section):
+        s = old.pop(t)
+        s["section"], s["section_label"] = section, label
+        return s
+
+    title["subtitle"] = "Paper figure plan (Nature style) · updated 2026-10-08"
+    agenda["items"] = ([f"Fig. {f['n']}  {f['title']}" for f in plan["figures"]]
+                       + ["Supplementary", "Appendix"] + (["Discussion"] if plan.get("discussion") else []))
+    out = [title, agenda, plan_slide("Manuscript plan: six main figures", "Plan")]
+    for f in plan["figures"]:
+        n = f["n"]
+        out.append({"kind": "divider", "title": f"Figure {n}. {f['title']}"})
+        out.append(plan_slide(f"Figure {n} plan: {f['title']}", f"Fig. {n} plan"))
+        for p in f["panels"]:
+            for t in p["evidence"]:
+                out.append(plan_slide(t, f"Fig. {n}{p['p']}") if t in made else take(t, f"Fig. {n}{p['p']}", str(n)))
+        out += [take(t, f"Fig. {n} candidate", str(n)) for t in f.get("candidates", [])]
+        out += [take(t, f"Fig. {n} details", str(n)) for t in f["details"]]
+    out.append({"kind": "divider", "title": "Supplementary"})
+    out.append(plan_slide("Supplementary plan", "Supplementary"))
+    out += [take(t, "Supplementary", "S") for t in plan["supplementary"]["slides"]]
+    out.append({"kind": "divider", "title": "Appendix"})
+    out += [take(t, "Appendix", "A") for t in plan["appendix"]]
+    if plan.get("discussion"):
+        out.append({"kind": "divider", "title": "Discussion"})
+        out += [take(t, "Discussion", "D") for t in plan["discussion"]]
+    if old:
+        raise SystemExit(f"slides not placed: {sorted(old)}")
+    spec["slides"] = out
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    for i, s in enumerate(out, 1):
+        print(i, s.get("kind"), s.get("section_label", ""), "|", s.get("title"))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261008T022410Z-deconv-scsemi-deck/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec09_same_pairs.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Section 9 slide of the 2026-09-30 paper-summary deck: scSemiProfiler and LoRA given the SAME training pairs
+(5-fold CV, 2026-10-05; cohorts still running are shown as "in progress").
+
+CPU only. Per cohort, both methods use exactly the pairs of the other four folds (LoRA's training + inner-val rows =
+scSemiProfiler's representatives; checked for every fold by scsemi/tools/check_units.py) and are scored on all usable
+samples, each by the fold model that never saw it (one pooled score_ft.py call per method, same donors and reference):
+  LoRA            scores/<ds>/pooled/summary.json                          arm real_lora__raw
+  scSemiProfiler  scores/<ds>/scsemi_cv_20261002/pooled/summary.json       arm scsemi__raw
+  Giroux disease metrics from scores_nosex/ (sex-linked genes excluded), as in the deck.
+GPU time per fold (one GB10, every step alone on the GPU; data preparation and scoring not counted on either side):
+  LoRA            runs/<ds>/fold<k>/real_lora/RUN.json wall_seconds + the sampling job's wall clock in logs/run_queue_*.log
+  scSemiProfiler  scsemi/work/<ds>/cv/fold<k>/scsemi_project/models/*.receipt.json elapsed_seconds (stage 1 + 2 of every
+                  representative, complete, same run signature as the export) + the export's total_target_seconds
+  Read on the host that holds each fold's records (server_1 or spark-0110).
+The equal-pair-budget runs (n = 5..40, ImMicro and sepsis) are drawn on the "Pairs needed: composition, coverage, training steps" slide; quoted here.
+Outputs: figures/sec09_same_pairs.{png,pdf}, data/sec09_same_pairs.csv, data/sec09_same_pairs_slide_text.json
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # plotting only
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/"
+            "2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import sec09_paired_validation as S9  # noqa: E402
+import style  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+from matplotlib.patches import Patch  # noqa: E402
+
+T = S9.T
+ORDER, ROWNAME = S9.ORDER, S9.ROWNAME
+FS, SUB, EDGE = S9.FS, S9.SUB, S9.EDGE
+FIGDIR = Path(os.environ.get("DECK_FIGDIR", str(DECK / "figures")))
+OUTDATA = Path(os.environ.get("DECK_OUTDATA", str(DECK / "data")))
+CV = "scsemi_cv_20261002"
+BUDGET = "scsemi_budget_20261002"
+ARMS = [("scsemi", "scSemiProfiler, same pairs", style.ARM["scsemi"]), ("lora", "LoRA, same pairs", style.ARM["lora"])]
+# queue tag prefixes per cohort, tried in order; the sepsis fold-0 pilot queue used "sep"
+# (logs/run_queue_ye2026_sepsis_fold0_pilot_20260927T154613.log: sep_f0_real_lora_raw)
+TAG = {"immicro": ["imm"], "ye2026_sepsis": ["ye2", "sep"], "imperial_eskd": ["imp"], "giroux2022": ["gir"],
+       "ji2025_chili": ["ji2"]}
+
+COLLECT = r'''
+import glob, json, os, re, sys
+T = sys.argv[1]; TAG = json.loads(sys.argv[2])
+def jl(p):
+    try:
+        return json.load(open(p))
+    except Exception:
+        return None
+st, en = {}, {}
+for lg in sorted(glob.glob(os.path.join(T, "logs", "run_queue_*.log"))):
+    for line in open(lg, errors="replace"):
+        m = re.match(r"^(\S+) --- ([a-z0-9]+_f\d_real_lora_raw) seed=", line)
+        if m: st.setdefault(m.group(2), []).append(m.group(1))
+        m = re.match(r"^(\S+) ([a-z0-9]+_f\d_real_lora_raw) done:", line)
+        if m: en.setdefault(m.group(2), []).append(m.group(1))
+out = {}
+for ds, ps in TAG.items():
+    for k in range(5):
+        r = {}
+        run = jl(os.path.join(T, "runs", ds, f"fold{k}", "real_lora", "RUN.json"))
+        for p in ps:
+            tag = f"{p}_f{k}_real_lora_raw"
+            if run and len(st.get(tag, [])) >= 1 and len(en.get(tag, [])) >= 1:
+                r["lora"] = {"train_s": run["wall_seconds"], "start": st[tag][-1], "end": en[tag][-1], "tag": tag}
+                break
+        ex = jl(os.path.join(T, "generated", ds, f"fold{k}", "scsemi__raw.log"))
+        w = os.path.join(T, "scsemi", "work", ds, "cv", f"fold{k}")
+        asg = jl(os.path.join(w, "assignment.json"))
+        if ex and asg:
+            rec = [jl(f) for f in glob.glob(os.path.join(w, "scsemi_project", "models", "*.receipt.json"))]
+            rec = [x for x in rec if x and x.get("complete") and x.get("run_signature") == ex["run_signature"]]
+            r["scsemi"] = {"n_reps": len(asg["representative_indices"]), "n_rec": len(rec),
+                           "pretrain_s": sum(x["elapsed_seconds"] for x in rec), "target_s": ex["total_target_seconds"],
+                           "bulks": ex["bulks"]}
+        out[f"{ds}|{k}"] = r
+print(json.dumps(out))
+'''
+
+
+def collect(host):
+    cmd = ["python3", "-", str(T), json.dumps(TAG)]
+    if host != "server_1":
+        cmd = ["ssh", "spark-0110"] + ["python3", "-", str(T), "'" + json.dumps(TAG) + "'"]
+    res = subprocess.run(cmd, input=COLLECT, capture_output=True, text=True, check=True)
+    return json.loads(res.stdout)
+
+
+def load(p):
+    f = p / "summary.json"
+    return json.loads(f.read_text()) if f.exists() else None
+
+
+def main() -> int:
+    got = {h: collect(h) for h in ("server_1", "server_2")}
+    vals, rows, done = {}, [], []
+    for ds in ORDER:
+        lo, sc = load(T / "scores" / ds / "pooled"), load(T / "scores" / ds / CV / "pooled")
+        if sc is None or "scsemi__raw" not in sc["arms"]:
+            continue
+        if set(lo["donors"]) != set(sc["donors"]) or lo["reference"]["reference_sha256"] != sc["reference"]["reference_sha256"]:
+            raise SystemExit(f"{ds}: LoRA and scSemiProfiler pooled calls differ in donors or reference")
+        hl, hs = dict(lo["headline"]["real_lora__raw"]), dict(sc["headline"]["scsemi__raw"])
+        if ds == "giroux2022":
+            nl, ns = load(T / "scores_nosex" / ds / "pooled"), load(T / "scores_nosex" / ds / CV / "pooled")
+            if ns is None:
+                hs["contrast_mean_cp10k_r_gen"] = np.nan
+                hs["deg_top50_sum"] = None
+            for h, n, a in ((hl, nl, "real_lora__raw"), (hs, ns, "scsemi__raw")):
+                if n is not None:
+                    h["contrast_mean_cp10k_r_gen"] = n["headline"][a]["contrast_mean_cp10k_r_gen"]
+                    h["deg_top50_sum"] = n["headline"][a].get("deg_top50_sum")
+        if hl.get("deg_top50_sum") is None:   # older pooled LoRA scorings keep the DEG score in pooled_deg/
+            pd_ = load(T / ("scores_nosex" if ds == "giroux2022" else "scores") / ds / "pooled_deg")
+            if pd_ is not None and set(pd_["donors"]) == set(lo["donors"]) and "real_lora__raw" in pd_["headline"]:
+                hl["deg_top50_sum"] = pd_["headline"]["real_lora__raw"].get("deg_top50_sum")
+        t = {"lora": [], "scsemi": []}
+        for k in range(5):
+            for m in ("lora", "scsemi"):
+                rec = [g[f"{ds}|{k}"][m] for g in got.values() if m in g.get(f"{ds}|{k}", {})
+                       and (m == "lora" or g[f"{ds}|{k}"][m]["n_rec"] == 2 * g[f"{ds}|{k}"][m]["n_reps"])]
+                if len(rec) != 1:
+                    raise SystemExit(f"{ds} fold {k} {m}: {len(rec)} complete timing records across hosts")
+                r = rec[0]
+                if m == "lora":
+                    gen = (pd.Timestamp(r["end"]) - pd.Timestamp(r["start"])).total_seconds()
+                    t[m].append((r["train_s"] + gen) / 3600)
+                else:
+                    t[m].append((r["pretrain_s"] + r["target_s"]) / 3600)
+        for m, h in (("lora", hl), ("scsemi", hs)):
+            vals[(ds, m)] = {"comp_l1": h["comp_l1"], "coverage": h["coverage"], "precision": h["precision"],
+                             "logfc_r": h.get("contrast_mean_cp10k_r_gen", np.nan), "deg": h.get("deg_top50_sum"),
+                             "hours": float(np.mean(t[m])), "hours_min": min(t[m]), "hours_max": max(t[m])}
+            rows.append({"dataset": ds, "arm": m, **vals[(ds, m)], "n_scored": lo["n_donors"],
+                         "source": str(T / "scores" / ds / (CV + "/pooled" if m == "scsemi" else "pooled") / "summary.json")})
+        done.append(ds)
+    if not done:
+        raise SystemExit("no cohort has a scored scSemiProfiler 5-fold CV yet")
+    # equal pair budget (quoted only)
+    bud = []
+    for ds in ORDER:
+        sb, lo = load(T / "scores" / ds / BUDGET / "pooled"), load(T / "scores" / ds / "pooled")
+        if sb is None:
+            continue
+        for n in (5, 10, 20, 40):
+            a, b = f"scsemi_n{n}__raw", f"lora_n{n}__raw"
+            if a in sb["arms"] and b in lo["arms"]:
+                bud.append({"dataset": ds, "n": n, "scsemi_l1": sb["headline"][a]["comp_l1"],
+                            "lora_l1": lo["headline"][b]["comp_l1"], "scsemi_cov": sb["headline"][a]["coverage"],
+                            "lora_cov": lo["headline"][b]["coverage"]})
+    bud = pd.DataFrame(bud)
+
+    panels = [("comp_l1", "Composition L1 ↓", None), ("coverage", "Coverage ↑", (0, 1)),
+              ("logfc_r", "Disease logFC r ↑", (0, 1)), ("hours", "GPU hours per fold", None)]
+    fig, axes = plt.subplots(1, 4, figsize=(12.3, 4.2), gridspec_kw={"wspace": 0.12})
+    h = 0.36
+    y = np.arange(len(ORDER)) * 1.0
+    for ax, (mk, lab, lim) in zip(axes, panels):
+        for i, ds in enumerate(ORDER):
+            if ds == "immicro" and mk == "logfc_r" and ds in done:
+                ax.text(0.03, y[i], "healthy cohort: no contrast", transform=ax.get_yaxis_transform(), va="center",
+                        fontsize=FS - 4, color=SUB)
+                continue
+            if ds not in done:
+                ax.text(0.03, y[i], "in progress", transform=ax.get_yaxis_transform(), va="center", fontsize=FS - 4,
+                        color=SUB)
+                continue
+            for k, (m, _l, col) in enumerate(ARMS):
+                v = vals[(ds, m)][mk]
+                yy = y[i] + (k - 0.5) * h
+                if v is None or np.isnan(v):
+                    ax.text(0.03, yy, "no contrast" if ds == "immicro" else "n/a", transform=ax.get_yaxis_transform(),
+                            va="center", fontsize=FS - 5, color=SUB)
+                    continue
+                ax.barh(yy, v, h * 0.9, color=col, edgecolor="none")
+                if mk == "hours":
+                    vv = vals[(ds, m)]
+                    s = (f"{vv['hours_min'] * 60:.0f}–{vv['hours_max'] * 60:.0f} min" if m == "lora"
+                         else f"{vv['hours_min']:.1f}–{vv['hours_max']:.1f} h")
+                else:
+                    s = f"{v:.2f}"
+                ax.text(v * (1.12 if mk == "hours" else 1.0) + (0 if mk == "hours" else 0.015), yy, s, va="center",
+                        fontsize=FS - 5, color=SUB)
+        ax.set_title(lab, fontsize=FS - 1)
+        ax.set_yticks(y, [ROWNAME[d] for d in ORDER] if ax is axes[0] else [""] * len(ORDER), fontsize=FS - 3)
+        ax.set_ylim(len(ORDER) - 0.5, -0.5)
+        ax.tick_params(axis="y", length=0)
+        ax.tick_params(axis="x", labelsize=FS - 4)
+        if lim:
+            ax.set_xlim(*lim)
+        if mk == "comp_l1":
+            ax.set_xlim(0, 0.75)
+        if mk == "hours":
+            ax.set_xscale("log")
+            ax.set_xlim(0.03, 40)
+            ax.set_xticks([0.1, 1, 10], ["0.1", "1", "10"])
+            ax.minorticks_off()
+        ax.grid(axis="x", color="#E3E3E3", linewidth=0.8)
+        ax.set_axisbelow(True)
+    fig.legend(handles=[Patch(color=c, label=l) for _, l, c in ARMS], loc="lower center", ncol=2,
+               bbox_to_anchor=(0.5, -0.08), fontsize=FS - 2)
+    style.save(fig, "sec09_same_pairs", FIGDIR)
+    OUTDATA.mkdir(exist_ok=True)
+    pd.DataFrame(rows).to_csv(OUTDATA / "sec09_same_pairs.csv", index=False, float_format="%.6g")
+    if len(bud):
+        bud.to_csv(OUTDATA / "sec09_same_pairs_budget.csv", index=False, float_format="%.6g")
+
+    metrics = {"comp_l1": "composition", "coverage": "coverage", "precision": "precision", "logfc_r": "logFC r"}
+    valid = {k: [d for d in done if not np.isnan(vals[(d, 'lora')][k]) and not np.isnan(vals[(d, 'scsemi')][k])]
+             for k in metrics}
+    ahead = lambda d, k: (vals[(d, 'lora')][k] < vals[(d, 'scsemi')][k]) if k == "comp_l1" \
+        else (vals[(d, 'lora')][k] > vals[(d, 'scsemi')][k])  # noqa: E731
+    lw = {k: sum(ahead(d, k) for d in valid[k]) for k in metrics}
+    behind = {k: [S9.NAME[d] for d in valid[k] if not ahead(d, k)] for k in metrics}
+    ratio = [vals[(d, "scsemi")]["hours"] / vals[(d, "lora")]["hours"] for d in done]
+    allwin = [k for k in metrics if valid[k] and lw[k] == len(valid[k])]
+    rest = [k for k in metrics if valid[k] and k not in allwin]
+    gpu_kw = f"{min(ratio):.0f}–{max(ratio):.0f}× less GPU time per fold"
+    if not rest:
+        kw = ["Same pairs: LoRA ahead on every metric",
+              f"Coverage {vals[(done[0], 'lora')]['coverage']:.2f} vs {vals[(done[0], 'scsemi')]['coverage']:.2f} "
+              f"({S9.NAME[done[0]]})", gpu_kw]
+    else:
+        kw = ["LoRA ahead in " + ", ".join(f"{metrics[k]} {lw[k]}/{len(valid[k])}" for k in rest), gpu_kw]
+        if allwin:
+            dens = {len(valid[k]) for k in allwin}
+            kw.insert(0, ", ".join(metrics[k] for k in allwin).capitalize() + ": LoRA ahead"
+                      + (f" in {dens.pop()}/{len(valid[allwin[0]])}" if len(dens) == 1 else " in all"))
+    for k in kw:
+        if len(k) > 45:
+            raise SystemExit(f"keyword too long: {k}")
+    numbers = [{"value": f"{S9.NAME[d]}: L1 LoRA {vals[(d, 'lora')]['comp_l1']:.3f} / scSemi {vals[(d, 'scsemi')]['comp_l1']:.3f}; "
+                         f"coverage {vals[(d, 'lora')]['coverage']:.3f} / {vals[(d, 'scsemi')]['coverage']:.3f}; precision "
+                         f"{vals[(d, 'lora')]['precision']:.3f} / {vals[(d, 'scsemi')]['precision']:.3f}; logFC r "
+                         f"{vals[(d, 'lora')]['logfc_r']:.3f} / {vals[(d, 'scsemi')]['logfc_r']:.3f}; top-50 DEG "
+                         f"{vals[(d, 'lora')]['deg']} / {vals[(d, 'scsemi')]['deg']}; GPU per fold LoRA "
+                         f"{vals[(d, 'lora')]['hours'] * 60:.1f} min / scSemi {vals[(d, 'scsemi')]['hours']:.2f} h",
+                "source": "data/sec09_same_pairs.csv"} for d in done]
+    btxt = ""
+    if len(bud):
+        for d, g in bud.groupby("dataset"):
+            btxt += (f" Equal pair budget, {S9.NAME[d]} (n = 5, 10, 20, 40 pairs): scSemiProfiler L1 "
+                     f"{g.scsemi_l1.min():.3f}–{g.scsemi_l1.max():.3f} and coverage {g.scsemi_cov.min():.2f}–"
+                     f"{g.scsemi_cov.max():.2f} at every n; LoRA L1 {g.lora_l1.min():.3f}–{g.lora_l1.max():.3f}, coverage "
+                     f"{g.lora_cov.min():.2f}–{g.lora_cov.max():.2f} (drawn on the 'Pairs needed: composition, coverage, training steps' slide).")
+        numbers.append({"value": btxt.strip(), "source": "data/sec09_same_pairs_budget.csv"})
+    pending = [S9.NAME[d] for d in ORDER if d not in done]
+    full = ("5-fold CV: for every fold, scSemiProfiler's representatives are exactly LoRA's training + inner-val pairs "
+            "(the other four folds; checked per fold), test = the fold's samples from their real bulk only. Pooled = one "
+            "scoring call per method over every usable sample, same donors and reference (sha-checked). scSemiProfiler = "
+            "upstream c2aea02, default settings, official output. GPU time per fold on one GB10: LoRA = fine-tune + "
+            "sampling 1,500 cells per test sample; scSemiProfiler = pretraining of every representative + one model per "
+            "test sample (receipts); data preparation and scoring not counted on either side. "
+            + "".join(f"scSemiProfiler ahead on {metrics[k]}: {', '.join(behind[k])}. " for k in metrics if behind[k])
+            + ("Still running (server_1 / server_2): " + ", ".join(pending) + "." if pending else "")
+            + btxt + " Source: plans/paired_finetune_intradataset_20260927/scores/<cohort>/{pooled,scsemi_cv_20261002/pooled}/ "
+            "and scsemi/analysis/cv_budget_20261005/.")
+    txt = {"title": "Same training pairs: LoRA vs scSemiProfiler", "layout": "full",
+           "figures": [str(FIGDIR / "sec09_same_pairs.png")], "keywords": kw,
+           "footnote_short": ("5-fold CV; scSemiProfiler representatives = LoRA's training pairs. "
+                              + (f"{', '.join(pending)}: running." if pending else "")),
+           "footnote": full, "numbers": numbers}
+    if len(txt["footnote_short"]) > 110:
+        raise SystemExit("short footnote too long")
+    out = {"section": "09-same-pairs", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/sec09_same_pairs.py (rerun to refresh; do not edit by hand)", "slides": [txt]}
+    (OUTDATA / "sec09_same_pairs_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw))
+    for n in numbers:
+        print(n["value"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())