structflo-cser 0.4.0__tar.gz → 0.4.2__tar.gz

structflo_cser-0.4.2/.dockerignore

@@ -0,0 +1,19 @@
+.git
+.github
+.venv
+.ruff_cache
+.pytest_cache
+__pycache__
+*.pyc
+
+# training data, model runs, and notebook assets — none of it belongs in the image
+data/
+runs/
+detections/
+archive/
+notebooks/
+docs/
+scripts/
+asset_scripts/
+tests/
+*.pt

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/.gitignore

@@ -40,6 +40,8 @@ Thumbs.db
 runs/
 detections/
 archive/
+# Zenodo reproducibility bundle (weights + synth test set; upload, don't commit)
+repro_release/
 
 # ── Project: datasets & generated data ───────────────────────────────────────
 /data/

structflo_cser-0.4.2/.gitlab-ci.yml

@@ -0,0 +1,34 @@
+# Lab deployment image. GitHub (structflo/structflo-cser) stays the source of
+# truth; this mirror exists to build for the SACNet swarm registry.
+image: docker:latest
+
+services:
+  - docker:dind
+
+variables:
+  DOCKER_DRIVER: overlay2
+  IMAGE_TAG: "$CI_REGISTRY/sid/structflo-cser:$CI_COMMIT_REF_NAME"
+  GIT_DEPTH: 0        # git describe needs the tag history
+
+stages:
+  - build
+
+# Build and push in one job on purpose: separate jobs get separate dind
+# daemons, so an image built in one is not present in the other.
+build:
+  stage: build
+  script:
+    - docker info
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
+    # VERSION feeds SETUPTOOLS_SCM_PRETEND_VERSION. The image has no .git, and
+    # weights.py refuses to load cser-relmatcher below 0.3.0 — an image built
+    # without a real version looks fine until the first upload fails.
+    - apk add --no-cache git
+    - git fetch --tags --force || true
+    - VERSION=$(git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
+    - test -n "$VERSION" || { echo "no git tag reachable; cannot stamp a version"; exit 1; }
+    - echo "building $IMAGE_TAG at version $VERSION"
+    - docker build --build-arg VERSION="$VERSION" -t $IMAGE_TAG .
+    - docker push $IMAGE_TAG
+  only:
+    - main

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/CLAUDE.md

@@ -10,9 +10,11 @@ strings and OCR text.
 ## Package name & layout
 
 - **PyPI package**: `structflo-cser`
-- **Top-level packages** (wheel): `structflo`, `annotate`
+- **Top-level packages** (wheel): `structflo`, `annotate`, `webapp`
 - **Source root**: `structflo/cser/` — all library code lives here
 - **Annotate tool**: `annotate/` — Flask web app for manual bbox annotation
+- **Extraction UI**: `webapp/` — Flask web app for running the pipeline on an upload
+  (no auth; expects a reverse proxy in front)
 
 ### Module map
 
@@ -77,6 +79,10 @@ annotate/
   pdf.py               PDF page rendering for annotation
   storage.py           Annotation JSON storage
   templates/           HTML templates
+
+webapp/
+  server.py            Flask routes + CLI (upload → NDJSON stream of pairs per page)
+  templates/           Single-page UI: page overlay + structure→SMILES cards
 ```
 
 ## CLI entry points (registered in pyproject.toml)
@@ -93,6 +99,7 @@ annotate/
 | `sf-annotate`             | `annotate.__main__:main`                  | Manual annotation web tool           |
 | `sf-train-lps`            | `structflo.cser.lps.train:main`           | Train Learned Pair Scorer            |
 | `sf-eval-lps`             | `structflo.cser.lps.evaluate:main`        | Evaluate LPS model                   |
+| `sf-web`                  | `webapp.server:main`                      | Upload → IDs + SMILES web UI         |
 
 ## Key public API
 
@@ -144,10 +151,15 @@ ChemPipeline.to_records(pairs)
 Weights are versioned independently of the package and stored on HuggingFace Hub.
 `structflo.cser.weights.resolve_weights(model, version)` handles auto-download + caching.
 
-| Model          | HF Repo                         | Latest |
-|----------------|----------------------------------|--------|
-| cser-detector  | sidxz/structflo-cser-detector   | v0.2   |
-| cser-lps       | sidxz/structflo-cser-lps        | v0.1   |
+| Model           | HF Repo                          | Latest |
+|-----------------|----------------------------------|--------|
+| cser-detector   | sidxz/structflo-cser-detector    | v0.4   |
+| cser-lps        | sidxz/structflo-cser-lps         | v0.3   |
+| cser-relmatcher | sidxz/structflo-cser-relmatcher  | v0.2   |
+
+v0.4 / v0.3 / v0.2 were trained on the 914-doc real corpus (the original 830 + 84 newly
+annotated docs, of which 60 complete). Earlier releases: detector v0.3 / lps v0.2 / relmatcher v0.1
+(830-doc corpus).
 
 Publish script: `scripts/publish_weights.py`
 

structflo_cser-0.4.2/Dockerfile

@@ -0,0 +1,41 @@
+FROM python:3.12-slim
+
+# rdkit + opencv (via ultralytics/easyocr) need libGL and glib at runtime.
+# libxrender1/libxext6 are for rdkit.Chem.Draw, which webapp/server.py imports
+# lazily to re-render each extracted SMILES: without them the app boots clean and
+# then fails on the first page that actually finds a compound.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      libgl1 libglib2.0-0 libxrender1 libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# The package version comes from git tags via hatch-vcs, and .git is not in the
+# build context (see .dockerignore). Without this the build fails outright, and
+# a wrong version silently trips the weights compatibility gate in weights.py —
+# cser-relmatcher requires >=0.3.0. CI passes the release tag.
+ARG VERSION=0.0.0
+ENV SETUPTOOLS_SCM_PRETEND_VERSION=$VERSION
+
+COPY pyproject.toml README.md ./
+COPY structflo/ ./structflo/
+COPY annotate/ ./annotate/
+COPY webapp/ ./webapp/
+RUN pip install --no-cache-dir .
+
+# Every model this app uses is downloaded on first run: YOLO detector + LPS +
+# relmatcher from HF Hub, DECIMER via pystow, EasyOCR's craft/english weights.
+# That is several GB, so point them all at one directory and mount it — a bare
+# container re-downloads the lot on every start.
+ENV HF_HOME=/cache/huggingface \
+    PYSTOW_HOME=/cache/pystow \
+    EASYOCR_MODULE_PATH=/cache/easyocr \
+    MPLCONFIGDIR=/cache/matplotlib
+VOLUME /cache
+
+EXPOSE 8000
+
+ENTRYPOINT ["sf-web"]
+# --preload pays the model-loading cost at startup instead of on the first
+# upload. Drop it if you would rather the container come up immediately.
+CMD ["--host", "0.0.0.0", "--port", "8000", "--preload"]

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structflo-cser
-Version: 0.4.0
+Version: 0.4.2
 Summary: Chemical structure-label pair extraction from scientific documents.
 Requires-Python: >=3.11
 Requires-Dist: chembl-webresource-client>=0.10.9
@@ -11,6 +11,7 @@ Requires-Dist: huggingface-hub>=0.24.0
 Requires-Dist: matplotlib>=3.10.8
 Requires-Dist: numpy>=2.4.2
 Requires-Dist: opencv-python-headless>=4.13.0.92
+Requires-Dist: openpyxl>=3.1
 Requires-Dist: packaging>=23.0
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: pillow>=12.1.1

structflo_cser-0.4.2/docs/REPRODUCIBILITY_HANDOFF.md

@@ -0,0 +1,272 @@
+# Reproducibility Handoff — Retrain matchers (≥3 seeds) & re-verify all paper numbers
+
+**Created:** 2026-06-01. **For:** a fresh session.
+**Goal:** Remove all weight-provenance ambiguity and establish **reproducible, multi-seed
+(≥3)** results for the structure–label matcher benchmark (and the detection/LPS numbers it
+depends on), cleanly separated into the paper's two sections. Report **mean ± std** across
+training seeds.
+
+---
+
+## 0. Why this handoff exists (the problem to fix)
+
+During paper review we could **not determine from artifacts** whether the existing relational
+checkpoints were trained on synthetic-only vs real+synthetic data:
+
+- `runs/relmatch` — **GT-box-trained** variant (clean geometry). `sf-train-relmatch`'s
+  **default `--data-dir` is `data/finetune/lps` (real+synthetic)** and its default output is
+  `runs/relmatch`, so this checkpoint was *most likely trained on real+synthetic*, **not**
+  synthetic-only. Unconfirmed.
+- `runs/relmatch_det` — **detection-box-trained** variant. Trained on
+  `data/finetune/relmatch_det` (1,242 real + 1,834 synthetic json). This is the **PUBLISHED**
+  matcher (`cser-relmatcher` v0.1 = `runs/relmatch_det/best.pt`; the `ChemPipeline` default).
+- Checkpoints store no `data_dir`; no run logs survive. Hence the ambiguity.
+
+This matters because the paper is organized as:
+- **§A "Performance on Synthetic Data"** → must use **synthetic-only** weights, evaluated on a
+  held-out **synthetic test set @1280 px**.
+- **§B "Generalization to Internal Documents"** → must use the **real-fine-tuned / published**
+  weights (baseline = synthetic → fine-tuned improvement, on the real test set).
+
+If `runs/relmatch` is actually real-trained, then §A's relational row currently uses the wrong
+(real) weights, and there is **no synthetic-only relational matcher at all**. The retrain
+resolves this by training every matcher **from scratch with an explicit `--data-dir` and an
+explicit `--seed`**, logging everything.
+
+---
+
+## 1. The principle (don't deviate)
+
+| Section | Weights to use | Eval data |
+|---|---|---|
+| §A synthetic | **synthetic-only** (`--data-dir data/generated`) | synthetic **test** set, @1280 px |
+| §B internal | **real-fine-tuned / published** (mix `data/finetune/*`) | real **test** set (100 pages), @1280 px |
+
+- All detection/e2e evaluation at **imgsz 1280** (the deployment resolution). Do **not** rely on
+  `model.val()`'s default imgsz — it silently uses each checkpoint's *training* imgsz (base
+  detector = 2048, fine-tuned = 1280), which previously confounded a baseline-vs-finetuned
+  comparison. Always pass `imgsz=1280` explicitly. (`scripts/finetune/yolo/eval_compare.py`
+  already pins it.)
+- §A draws **no matcher conclusions** (matchers saturate in-distribution); all matcher
+  conclusions are on real data in §B. (User decision.)
+
+---
+
+## 2. Current single-seed numbers (the baseline to reproduce)
+
+These are what's in the paper draft now (`docs/paper_draft.md`, gitignored). The retrain should
+reproduce them within seed variance; **mean ± std replaces the point values**.
+
+**§A synthetic TEST set (1,000 pages, seed 1000000, WITH distractors), @1280:**
+- *Table 1 detection (base `yolo11l_panels`):* structure 0.998/1.000/0.995/0.990 ·
+  label 0.993/0.992/0.995/0.890 · all 0.995/0.996/0.995/0.940 (P/R/mAP50/mAP50-95)
+- *Table 2 matching (synthetic-only weights — relational here used `runs/relmatch`, TO BE
+  RE-ESTABLISHED as truly synthetic):* clean assign/reject/prec + e2e P/R/F1 —
+  Distance 99.0/89.8/99.0 · 0.971/0.974/0.973 ;
+  Relational 98.9/86.6/98.9 · 0.977/0.977/0.977 ;
+  LPS 97.0/94.1/99.5 · 0.991/0.944/0.967
+
+**§B real TEST set (100 pages; 247 labelled, 25 unlabelled), @1280:**
+- *Table 3 detector:* base→FT mAP50 0.691→0.871, mAP50-95 0.404→0.552, P 0.668→0.850,
+  R 0.755→0.897. Synthetic regression (synth test): mAP50 0.995→0.995, mAP50-95 0.940→0.953.
+- *Table 3 LPS pair-classification:* real test 85.2%→90.7% ; synth test 96.7%→96.2%.
+- *Table 4 clean matching:* Distance 99.6/96.0/99.6 ; LPS 91.1/96.0/98.3 ;
+  Relational **with published `relmatch_det`** 98.0/96.0/99.6 **(current paper value)** ;
+  Relational with GT-trained `runs/relmatch` 99.2/100.0/100.0 (alternative — unpublished variant).
+- *Table 5 e2e:* Distance 0.815/0.818/0.816 ; LPS 0.842/0.713/0.772 ;
+  Relational (`relmatch_det`) 0.838/0.773/0.804.
+
+> Open decision the user was mid-answering: whether §B Table 4 reports the **published
+> `relmatch_det`** (96% rejection, drops the "relational rejects best/100%" claim — already
+> edited into the draft + abstract + conclusions) or also shows the GT-trained variant's
+> 99.2/100/100 as an ablation. After the retrain, re-surface this with clean numbers.
+
+---
+
+## 3. Prerequisites / data inventory
+
+```bash
+uv sync --dev
+```
+
+- **Synthetic train/val:** `data/generated/{train,val}/{images,ground_truth,labels}` (10k/1k).
+- **Synthetic TEST set:** `data/generated_test/val/...` (1,000 pages). If missing, regenerate
+  EXACTLY (seed-disjoint from train/val, with distractors):
+  ```bash
+  uv run sf-generate --out data/generated_test --num-train 0 --num-val 1000 \
+    --seed 1000000 --smiles data/smiles/chembl_smiles.csv --fonts-dir data/fonts \
+    --distractors-dir data/distractors --workers 0
+  ```
+- **Real (CONFIDENTIAL):** mounted at `/net-fs-ins/shared-docker-vols/structflo-cser-annotate/data`
+  (`ground_truth/`, `images/`); split manifest `data/finetune/real_split.json`
+  (test=100, val=75, train=830, seed 42). Fine-tune corpora:
+  `data/finetune/lps/{train,val,real_test}` (GT boxes, 1,660 real + 2,000 synth in train),
+  `data/finetune/relmatch_det/{train,val}` (detection boxes), `data/finetune/yolo/` (+ `data_real_test.yaml`).
+- **Detector checkpoints (reuse, do NOT retrain unless you accept the GPU cost — see §6):**
+  base synthetic `runs/labels_detect/yolo11l_panels/weights/best.pt` (trained imgsz **2048**);
+  fine-tuned `runs/labels_detect/finetune_3way/weights/best.pt` (imgsz 1280).
+
+---
+
+## 4. Retrain plan — matchers, ≥3 seeds, explicit provenance
+
+Use **SEEDS = {42, 43, 44}**. Put everything under `runs/repro/`. Both trainers honor `--seed`.
+
+```bash
+for S in 42 43 44; do
+  # ---- §A: SYNTHETIC-ONLY matchers (explicit --data-dir data/generated) ----
+  uv run sf-train-lps        --data-dir data/generated --seed $S \
+        --output-dir runs/repro/lps_synth_s$S
+  uv run sf-train-relmatch   --data-dir data/generated --seed $S \
+        --output-dir runs/repro/relmatch_synth_s$S          # GT-box, synthetic
+
+  # ---- §B: REAL-FINE-TUNED matchers ----
+  uv run sf-train-lps        --finetune runs/repro/lps_synth_s$S/best.pt \
+        --data-dir data/finetune/lps --seed $S \
+        --output-dir runs/repro/lps_ft_s$S
+  uv run sf-train-relmatch   --data-dir data/finetune/lps --seed $S \
+        --output-dir runs/repro/relmatch_gt_s$S             # GT-box, real+synth (clean variant)
+  uv run sf-train-relmatch   --det-data-dir data/finetune/relmatch_det --seed $S \
+        --output-dir runs/repro/relmatch_det_s$S            # detection-box, real+synth (PUBLISHED kind)
+done
+```
+
+Notes:
+- `sf-train-relmatch` has **no `--finetune`** (always trains from scratch); `--det-data-dir`
+  switches it to detection-box training (overrides `--data-dir`).
+- LPS fine-tune warm-starts from the **same seed's** synthetic base for clean seed isolation.
+- Training is cheap: LPS ~minutes, relmatch ~minutes/seed. The whole matrix is well under an hour.
+
+---
+
+## 5. Eval plan — per seed, on the FIXED test sets
+
+Create the synthetic-test manifest once:
+```bash
+uv run python - <<'PY'
+import json, glob, os
+stems = sorted(os.path.splitext(os.path.basename(p))[0]
+               for p in glob.glob('data/generated_test/val/ground_truth/*.json'))
+json.dump({'test': stems, 'val': [], 'train': []}, open('runs/repro/synth_test_manifest.json','w'))
+print('pages', len(stems))
+PY
+```
+
+**(a) Synthetic matching — Table 2 (per seed):** synthetic-only weights on the synthetic test set.
+```bash
+for S in 42 43 44; do
+  uv run python scripts/finetune/relmatch/eval_compare_all.py \
+    --src data/generated_test/val --manifest runs/repro/synth_test_manifest.json \
+    --detector runs/labels_detect/yolo11l_panels/weights/best.pt \
+    --lps runs/repro/lps_synth_s$S/best.pt \
+    --relmatch runs/repro/relmatch_synth_s$S/best.pt \
+    --imgsz 1280 --conf 0.3 | tee runs/repro/eval_synth_s$S.txt
+done
+# Read the [TEST] block: PART A = clean (assign/reject/prec), PART B = e2e (P/R/F1).
+```
+
+**(b) Real matching — Tables 4 & 5 (per seed):** fine-tuned/published weights on the real test set.
+```bash
+for S in 42 43 44; do
+  uv run python scripts/finetune/relmatch/eval_compare_all.py \
+    --detector runs/labels_detect/finetune_3way/weights/best.pt \
+    --lps runs/repro/lps_ft_s$S/best.pt \
+    --relmatch runs/repro/relmatch_det_s$S/best.pt \
+    --imgsz 1280 --conf 0.3 --margin 2.0 | tee runs/repro/eval_real_s$S.txt
+done
+# (default --src is the network mount; default --manifest is data/finetune/real_split.json)
+# For the §B Table 4 "GT-trained clean variant" ablation, also run with
+#   --relmatch runs/repro/relmatch_gt_s$S/best.pt   and record PART A only.
+```
+
+**(c) LPS pair-classification accuracy — Table 3 LPS row + synth regression (per seed):**
+use the helper `scripts/repro/eval_lps_acc.py` (created in this handoff).
+```bash
+for S in 42 43 44; do
+  uv run python scripts/repro/eval_lps_acc.py \
+     --weights runs/repro/lps_synth_s$S/best.pt --data data/finetune/lps/real_test   # baseline, real
+  uv run python scripts/repro/eval_lps_acc.py \
+     --weights runs/repro/lps_ft_s$S/best.pt    --data data/finetune/lps/real_test   # fine-tuned, real
+  uv run python scripts/repro/eval_lps_acc.py \
+     --weights runs/repro/lps_synth_s$S/best.pt --data data/generated_test/val       # baseline, synth
+  uv run python scripts/repro/eval_lps_acc.py \
+     --weights runs/repro/lps_ft_s$S/best.pt    --data data/generated_test/val       # fine-tuned, synth
+done
+```
+
+**(d) Detection — Tables 1 & 3 (detector is single-model; see §6):**
+```bash
+# Synthetic Table 1 (base @1280 on synth test):
+uv run yolo detect val model=runs/labels_detect/yolo11l_panels/weights/best.pt \
+  data=<synth_test.yaml> split=val imgsz=1280 verbose=True
+# Real Table 3 detector (base vs FT @1280) + synth regression:
+uv run python scripts/finetune/yolo/eval_compare.py
+```
+`<synth_test.yaml>`: a data.yaml with `path: .../data/generated_test`, `val: val/images`,
+`nc: 2`, names {0: chemical_structure, 1: compound_label}.
+
+---
+
+## 6. Detector seeds — cost note / decision
+
+The detector is standard YOLO11l; the paper's **contribution is the matcher**. A 3-seed detector
+retrain is **expensive** (base ~hours/seed at imgsz 2048; fine-tune ~45 min/seed). Recommended:
+- **Keep the existing detector single-seed** for Tables 1 & 3 (detection is not the novelty), and
+  report matcher reproducibility via **Part A (clean), which is detector-independent**, plus e2e
+  with the fixed detector.
+- Only do multi-seed detector if the reviewer/user explicitly wants e2e variance to include
+  detector seeds. If so, retrain base (`config/data.yaml`, imgsz 2048, 30 ep) and fine-tune
+  (`scripts/finetune/yolo/train.sh`, imgsz 1280) per seed and re-run (a)/(b)/(d) per detector seed.
+
+---
+
+## 7. Aggregate & update the paper
+
+1. Parse each `runs/repro/eval_*_s*.txt` [TEST] block → collect per-seed values.
+2. Compute **mean ± std** across the 3 seeds for every cell of Tables 2, 4, 5 and the LPS rows.
+3. Update `docs/paper_draft.md` Tables 1–5 to report mean ± std (keep §A "no conclusions";
+   keep §B conclusions). Note in each caption: "mean ± std over 3 training seeds (42–44);
+   synthetic-only weights for §A, fine-tuned for §B; eval @1280."
+4. Re-confirm the §B Table 4 relational decision (published `relmatch_det` vs GT-trained
+   ablation) with the user using the fresh multi-seed numbers.
+5. Sanity-check: fresh numbers should land within ~±1% of §2. Large drift ⇒ investigate.
+
+---
+
+## 8. Publish (after numbers are locked)
+
+Pick a canonical seed (or the median-seed checkpoint) for the released weights and bump versions:
+```bash
+python scripts/publish_weights.py --model cser-detector  --version vX.Y --weights-file <...>
+python scripts/publish_weights.py --model cser-lps        --version vX.Y --weights-file runs/repro/lps_ft_s42/best.pt
+python scripts/publish_weights.py --model cser-relmatcher --version vX.Y --weights-file runs/repro/relmatch_det_s42/best.pt
+```
+Document the seed + training `--data-dir` in the HF model card so provenance is never ambiguous again.
+
+---
+
+## 9. Gotchas / lessons (don't relearn these)
+
+- **`model.val()` imgsz**: silently uses the checkpoint's training imgsz. Always pass `imgsz=1280`.
+- **Two relational variants**: GT-box (`relmatch`) vs detection-box (`relmatch_det`). Published =
+  `relmatch_det`. Keep them straight; record `--data-dir`/`--det-data-dir` per run.
+- **Synthetic test set** must be **seed-disjoint** from train/val (train/val used seeds 7–11006;
+  test uses 1000000) and generated **with distractors** to match the realistic distribution.
+- **Real data is confidential** — never copy it into git, notebooks, or the released package.
+- **Paper draft is gitignored** (`.gitignore:48` `docs/*draft*.md`); edits live on disk only.
+- The synthetic LPS-classification eval over 1,000 pages is slow (visual-crop extraction) — run
+  in the background; real_test (100 pages) is fast.
+- `runs/`, `data/` are gitignored; `runs/repro/` will not be committed (that's fine — logs + the
+  aggregated table are the durable artifacts; copy the aggregated table into the paper).
+
+---
+
+## 10. Definition of done
+
+- [ ] `runs/repro/` holds all seeded checkpoints + `eval_*_s*.txt` logs (3 seeds).
+- [ ] Aggregated mean ± std table (e.g. `runs/repro/SUMMARY.md`) for Tables 2, 4, 5 + LPS rows.
+- [ ] `runs/relmatch` provenance resolved: a **confirmed synthetic-only** relational matcher
+      exists (`runs/repro/relmatch_synth_s*`) and is used in §A; published `relmatch_det`-kind in §B.
+- [ ] Paper Tables 1–5 updated to mean ± std with provenance noted in captions.
+- [ ] §B Table 4 relational decision re-confirmed with the user on fresh numbers.
+- [ ] (Optional) Re-published weights with documented seed + data provenance.

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/pyproject.toml

@@ -11,6 +11,7 @@ dependencies = [
     "matplotlib>=3.10.8",
     "easyocr>=1.7",
     "numpy>=2.4.2",
+    "openpyxl>=3.1",
     "opencv-python-headless>=4.13.0.92",
     "pillow>=12.1.1",
     "pymupdf>=1.27.1",
@@ -36,6 +37,7 @@ sf-extract              = "structflo.cser.pipeline.cli:main"
 sf-train-lps            = "structflo.cser.lps.train:main"
 sf-eval-lps             = "structflo.cser.lps.evaluate:main"
 sf-train-relmatch       = "structflo.cser.relmatch.train:main"
+sf-web                  = "webapp.server:main"
 
 [build-system]
 requires = ["hatchling<1.28", "hatch-vcs"]
@@ -45,7 +47,7 @@ build-backend = "hatchling.build"
 source = "vcs"
 
 [tool.hatch.build.targets.wheel]
-packages = ["structflo", "annotate"]
+packages = ["structflo", "annotate", "webapp"]
 
 [dependency-groups]
 dev = [

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/scripts/finetune/relmatch/eval_compare_all.py

@@ -60,8 +60,16 @@ def main():
     ap.add_argument("--relmatch", type=Path, default=Path("runs/relmatch_det/best.pt"))
     ap.add_argument("--margin", type=float, default=2.0, help="relational dustbin margin for Part B")
     ap.add_argument("--conf", type=float, default=0.3)
+    ap.add_argument(
+        "--label-conf",
+        type=float,
+        default=None,
+        help="per-class conf for labels (class 1); default = --conf. Lower it to give the "
+        "matcher more label candidates (Part B / end-to-end only; Part A uses GT boxes).",
+    )
     ap.add_argument("--imgsz", type=int, default=1280)
     args = ap.parse_args()
+    label_conf = args.label_conf if args.label_conf is not None else args.conf
 
     manifest = json.loads(args.manifest.read_text())
     stem2split = {}
@@ -113,12 +121,18 @@ def main():
 
         # ---- Part B inputs: detections (one YOLO pass) ----
         img_rgb = np.array(Image.open(ip).convert("L").convert("RGB"))
-        res = model(img_rgb, conf=args.conf, imgsz=args.imgsz, verbose=False)[0]
+        # Run YOLO at the lower of the two thresholds, then keep each class by its own conf:
+        # structures >= --conf, labels >= --label-conf (per-class gating for Part B).
+        res = model(img_rgb, conf=min(args.conf, label_conf), imgsz=args.imgsz, verbose=False)[0]
         det_dets = []
         for box in res.boxes:
+            cls = int(box.cls[0])
+            cf = float(box.conf[0])
+            if cf < (label_conf if cls == 1 else args.conf):
+                continue
             x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
             det_dets.append(Detection.from_dict({"bbox": [float(x1), float(y1), float(x2), float(y2)],
-                                                 "conf": float(box.conf[0]), "class_id": int(box.cls[0])}))
+                                                 "conf": cf, "class_id": cls}))
         labelled = [e for e in entries if e.get("label_bbox") is not None]
 
         for tgt in (split, "all"):
@@ -187,7 +201,7 @@ def main():
             print(f"    {n:>11} | {assign:>7.1%} {reject:>7.1%} {prec:>7.1%}")
 
     print("\n" + "=" * 70)
-    print(f"PART B — end-to-end full@{args.imgsz} → pairing F1 (centroid; Relational margin={args.margin})")
+    print(f"PART B — end-to-end full@{args.imgsz} (struct conf {args.conf}, label conf {label_conf}) → pairing F1 (centroid; Relational margin={args.margin})")
     print("=" * 70)
     for s in SPLITS:
         print(f"\n  [{s.upper()}]  GT pairs={gt_pairs[s]}")

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/scripts/finetune/relmatch/prepare_det_data.py

@@ -44,7 +44,8 @@ def _best(box, cands, thr):
     return bi
 
 
-def build_split(model, gt_dir, img_dir, out_dir, conf, imgsz):
+def build_split(model, gt_dir, img_dir, out_dir, conf, imgsz, label_conf=None):
+    label_conf = conf if label_conf is None else label_conf
     out_dir.mkdir(parents=True, exist_ok=True)
     files = sorted(gt_dir.glob("*.json"))
     n_pages = n_fp_struct = n_det_struct = n_missed_label = n_dustbin = n_real = 0
@@ -62,7 +63,7 @@ def build_split(model, gt_dir, img_dir, out_dir, conf, imgsz):
 
         img_rgb = np.array(Image.open(ip).convert("L").convert("RGB"))
         page_h, page_w = img_rgb.shape[:2]
-        res = model(img_rgb, conf=conf, imgsz=imgsz, verbose=False)[0]
+        res = model(img_rgb, conf=min(conf, label_conf), imgsz=imgsz, verbose=False)[0]
 
         d_struct_boxes, d_struct_conf = [], []
         d_label_boxes, d_label_conf = [], []
@@ -70,6 +71,8 @@ def build_split(model, gt_dir, img_dir, out_dir, conf, imgsz):
             x1, y1, x2, y2 = (float(v) for v in box.xyxy[0].cpu().numpy())
             cls = int(box.cls[0])
             cf = float(box.conf[0])
+            if cf < (label_conf if cls == 1 else conf):  # per-class gating
+                continue
             if cls == 0:
                 d_struct_boxes.append([x1, y1, x2, y2])
                 d_struct_conf.append(cf)
@@ -131,8 +134,18 @@ def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--src", type=Path, default=Path("data/finetune/lps"))
     ap.add_argument("--out", type=Path, default=Path("data/finetune/relmatch_det"))
-    ap.add_argument("--detector", type=Path, default=Path("runs/labels_detect/finetune_3way/weights/best.pt"))
+    ap.add_argument(
+        "--detector",
+        type=Path,
+        default=Path("runs/labels_detect/finetune_3way/weights/best.pt"),
+    )
     ap.add_argument("--conf", type=float, default=0.3)
+    ap.add_argument(
+        "--label-conf",
+        type=float,
+        default=None,
+        help="per-class conf for labels (class 1); default = --conf",
+    )
     ap.add_argument("--imgsz", type=int, default=1280)
     args = ap.parse_args()
 
@@ -148,6 +161,7 @@ def main():
             args.out / split,
             args.conf,
             args.imgsz,
+            label_conf=args.label_conf,
         )
     print(f"[prep] done → {args.out}")
 

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/scripts/finetune/yolo/eval_compare.py

@@ -39,7 +39,11 @@ def _val(weights: Path, data_yaml: Path) -> dict[str, float] | None:
         return None
 
     model = YOLO(str(weights))
-    m = model.val(data=str(data_yaml), verbose=False)
+    # Pin inference resolution so the baseline (trained @2048) and the
+    # fine-tuned model (trained @1280) are compared at the same deployment
+    # resolution. Without this, model.val() silently uses each checkpoint's own
+    # training imgsz, confounding the fine-tuning effect with a resolution change.
+    m = model.val(data=str(data_yaml), imgsz=1280, verbose=False)
 
     return {
         "mAP50": m.box.map50,

{structflo_cser-0.4.0 → structflo_cser-0.4.2}/scripts/finetune/yolo/train.sh

@@ -10,15 +10,18 @@
 set -euo pipefail
 
 PROJECT_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
-CHECKPOINT="$PROJECT_ROOT/runs/labels_detect/yolo11l_panels/weights/best.pt"
 OUT_DIR="$PROJECT_ROOT/runs/labels_detect"
 
 # Overridable via env vars (defaults reproduce the original trial run).
+# CHECKPOINT = base model to warm-start from (per-seed base for seed isolation).
+# SEED varies init/shuffle/augmentation only — data splits stay fixed.
+CHECKPOINT="${CHECKPOINT:-$PROJECT_ROOT/runs/labels_detect/yolo11l_panels/weights/best.pt}"
 DATA_YAML="${DATA_YAML:-$PROJECT_ROOT/data/finetune/yolo/data.yaml}"
 RUN_NAME="${RUN_NAME:-finetune_trial}"
 EPOCHS="${EPOCHS:-10}"
 PATIENCE="${PATIENCE:-5}"
 MOSAIC="${MOSAIC:-0.5}"
+SEED="${SEED:-42}"
 
 if [ ! -f "$DATA_YAML" ]; then
     echo "ERROR: $DATA_YAML not found. Run prepare_data.py first."
@@ -35,6 +38,7 @@ echo "  Data:       $DATA_YAML"
 echo "  Checkpoint: $CHECKPOINT"
 echo "  Run name:   $RUN_NAME"
 echo "  Epochs:     $EPOCHS  (patience $PATIENCE, mosaic $MOSAIC)"
+echo "  Seed:       $SEED"
 echo ""
 
 uv run python -c "
@@ -71,7 +75,7 @@ model.train(
     project='$OUT_DIR',
     name='$RUN_NAME',
     exist_ok=True,
-    seed=42,
+    seed=$SEED,
     plots=True,
     save_period=5,
 )