cross_tool_methodology.md

# Cross-tool AU benchmark — methodology & integration notes

This documents how py-feat is compared against other open-source Python facial
action-unit (AU) toolkits, and — just as importantly — **what it took to run
each competitor**. The integration effort is itself a result: it shows the
usability gap between py-feat (`pip install py-feat`, one `Detector` /
`Detectorv2` call, runs on any GPU) and the alternatives.

## Feature comparison

Across the open-source Python facial-behavior toolkits. ✅ = supported,
❌ = not supported, ⚠️ = supported with a caveat (see notes).

| | **py-feat** | **OpenFace 3.0** | **LibreFace** | **PyAFAR** |
|---|:---:|:---:|:---:|:---:|
| **Install** | `pip install py-feat` ✅ | clone repo + checkpoints | `pip install libreface` ⚠️¹ | ❌ broken deps² |
| **Single images** | ✅ | ✅ | ✅ | ❌ **video only** |
| **Video** | ✅ | ✅ | ✅ | ✅ |
| **Action units** | ✅ 20 | ✅ 8 | ✅ 12 (+5 occ.) | ⚠️ 12 occ. / 5 int. |
| **AU intensity** | ✅ | ❌ occ. only | ✅ | ⚠️ 5 AUs |
| **Emotion** | ✅ 7-class | ✅ | ✅ | ❌ |
| **Valence / arousal** | ✅ (v2) | ❌ | ❌ | ❌ |
| **Gaze** | ✅ | ✅ | ✅ | ❌ |
| **Head pose (6DoF)** | ✅ | ✅ | ✅ | ❌ |
| **Landmarks** | ✅ 68 + 478 mesh | ✅ | ✅ 478 mesh | ❌ |
| **Identity / face ID** | ✅ ArcFace | ❌ | ❌ | ❌ |
| **One-call API** | ✅ `Detector().detect()` | ❌ custom scripts | ✅ ⚠️¹ | ⚠️ video only |
| **Latest GPUs (Blackwell)** | ✅ | ✅ | ❌ pinned old torch³ | ❌ dlib/CUDA³ |
| **License** | permissive⁴ | academic | USC research-only | non-commercial |

¹ The `pip` model is a distilled all-in-one net that **underperforms its own
  paper**; reproducing published AU numbers requires cloning the research repo +
  checkpoints (see LibreFace notes).
² Release wheel pins `pysimplegui==4.60.5`, which was pulled from PyPI — install
  fails; needs `--no-deps` + hand-resolving TF/MediaPipe/dlib + `download_models`.
³ LibreFace's pinned PyTorch lacks Blackwell (sm_120) kernels (≤ Ampere only);
  PyAFAR's dlib build fails compiling CUDA kernels.
⁴ py-feat is permissively licensed; a few downloadable weights (e.g. ArcFace
  identity) are research-only and clearly flagged.

**Takeaway:** py-feat is the only one of the four that installs with a single
`pip` command, takes both images and video, runs on current-generation GPUs, and
covers the full feature set (AUs + intensity, emotion, valence/arousal, gaze,
6DoF pose, 68/478 landmarks, identity) behind one API.

## Accuracy — AU detection on DISFA+ (held-out)

Mean per-AU **F1** on the DISFA+ benchmark (57,150 frames). **Protocols are not
yet fully harmonized** across tools (AU subset + binarization differ — see the
per-tool note); treat as indicative until a single-protocol recompute lands.

| Tool | DISFA+ mean F1 | AUs scored | binarization | source |
|------|:---:|:---:|---|---|
| **py-feat v2** (`Detectorv2`) | **0.540** | 12 | truth ≥2, prob ≥0.5 | `pyfeat_disfaplus_au.json` |
| **OpenFace 3.0** | 0.488 | 8 | their `evaluation.py` | `openface3_disfaplus.json` |
| **LibreFace** (research RepVGG) | 0.461 | 12 | truth ≥2, intensity ≥2 | `libreface_repvgg_disfaplus.json` |
| **py-feat v1** (`Detector`, xgb) | 0.250 | 12 | truth ≥2, prob ≥0.5 | `pyfeat_disfaplus_au.json` |
| **PyAFAR** | 0.260 | **7 only** | occ ≥0.5, truth ≥2 | `pyafar_accuracy_disfaplus.json` |

**py-feat v2 (Detectorv2) leads** the held-out DISFA+ AU benchmark (0.54), ahead
of OpenFace 3.0 (0.49) and LibreFace (0.46) — and recall DISFA+ is held out for
*all* tools, while DISFA (LibreFace's/OF3's training set) is excluded. py-feat
v1's xgb path is weaker here (0.25) on the strict 12-AU / ≥2 protocol; it's the
legacy modular detector, and v2 is the recommended path.

**PyAFAR** now runs (its conda env rebuilt to its own declared TF-2.12 stack;
see notes) over all 57,150 frames, unmodified. It covers only **7 of the 12
DISFA AUs** (it has no AU05/09/20/25/26), and mean F1 over those 7 is **0.26** —
strong on the smile AUs (AU06 0.61, AU12 0.55) but failing AU01/AU04 (≈0). Its
video-only API required re-assembling DISFA+ stills into per-trial clips. The
0.26 is **not comparable to the 12-AU numbers above** (different, easier AU
subset); it's reported on PyAFAR's own 7-AU overlap.

LibreFace also gives mean intensity **PCC = 0.73** (its native DISFA metric).
A follow-up will recompute all tools on one AU set + threshold for an
apples-to-apples table.

## Accuracy — beyond AU: emotion, valence/arousal, gaze

AU is only one of the modalities these toolkits ship. We benchmark the rest on
the datasets that carry the right labels, each tool run **end-to-end as
written** (its own detector → its own model), on identical images/labels frozen
from py-feat's `feat.evaluation` loaders into shared manifests
(`shared/export_emotion_gaze_manifest.py`). Per-tool sample counts (`n`) differ
because each tool's *own* face detector decides which faces it finds — that
detection robustness is itself part of the comparison.

**Strictly out-of-sample.** Every number is on a held-out **validation/test**
split — no tool is ever scored on images from its own training set:

| Dataset | Split scored | Held out for |
|---|---|---|
| AffectNet | official **validation** (`validation_aligned.csv`) | all (tools train on AffectNet-train) |
| RAF-DB | **test** split | all (tools train on RAF-train) |
| DISFA+ | full posed-peak eval set | **all** — no tool trains on DISFA+ (we avoid DISFA, which several train on) |
| Columbia Gaze | full eval set | OF3, LibreFace only — ⚠️ **py-feat trained on all of it** |
| MPIIFaceGaze | held-out subsample | LibreFace only — ⚠️ **py-feat and OF3 both trained on it** |
| Gaze360 | **`bench`/test** split | LibreFace; held-out-in-distribution for py-feat & OF3 (both trained Gaze360-train) |

⚠️ Most gaze rows are contaminated (see the gaze section): py-feat trained on
Columbia/MPIIFaceGaze/Gaze360. The clean, frame-matched gaze benchmark is
**EYEDIAP** (out-of-sample for all, camera-frame). AU and emotion are genuinely
held-out.

### Emotion — 7-class, top-1 accuracy / macro-F1

Held-out **AffectNet-val** (994 imgs, classes 0–6) and **RAF-DB test** (3,068).
All three emotion-capable tools argmax their own emotion head; OF3/LibreFace
emit 8 classes (incl. Contempt) — scored on the shared 7, a Contempt prediction
counts as wrong. (PyAFAR has no emotion head.)

| Tool | AffectNet acc / F1 | RAF-DB acc / F1 |
|------|:---:|:---:|
| **py-feat v2** | 0.492 / **0.479** | **0.656 / 0.528** |
| **OpenFace 3.0** | **0.493** / **0.520** | 0.513 / 0.469 |
| **LibreFace** | 0.455 / 0.403 | 0.646 / 0.386 |

py-feat v2 and OF3 are neck-and-neck on AffectNet (0.49); on RAF-DB py-feat
leads on both accuracy and the balanced macro-F1 (LibreFace's 0.646 accuracy but
0.386 macro-F1 is the majority-class/Happiness skew).

### Valence / arousal — CCC (AffectNet-val)

**py-feat v2 is the only tool of the four that predicts continuous valence and
arousal at all** — so this isn't a head-to-head, it's a capability the others
lack. On AffectNet-val: **valence CCC 0.535, arousal CCC 0.482**.

### Gaze — use EYEDIAP; the rest are contaminated or frame-confounded

This is the subtlest comparison and took the most care. py-feat v2 trained on
**all four** of Columbia / MPIIFaceGaze / MPIIGaze / Gaze360 (confirmed in its
`au_deep` per-source training log), so those are in-distribution; ETH-XGaze is
out-of-sample but in a *normalized frame* py-feat never trained for. The one
benchmark that is **both out-of-sample for every tool and frame-matched** is
**EYEDIAP** (camera-frame gaze, no normalization), so that is the column to read:

| Tool | **EYEDIAP (clean)** | Columbia | MPIIFaceGaze | Gaze360 test | ETH-XGaze |
|------|:---:|:---:|:---:|:---:|:---:|
| **py-feat v2** | **20.0°** ✅ | 2.72° ❌over | 2.80° ❌over | 9.42° ⚠️in-dist | 44.6° ⚠️frame |
| **OpenFace 3.0** | 21.3° ✅ | 12.05° | 7.03° ❌over | 41.09° ❌over | 37.7° ⚠️frame |
| **LibreFace** | 23.7° ✅ | 15.40° | 19.49° | 32.08° | 40.5° |

✅ out-of-sample & frame-matched · ❌over = in-sample/overfit · ⚠️ = confounded

**EYEDIAP is the one clean, fair gaze comparison** — out-of-sample for all three
*and* in the camera frame (no head-normalization warp, unlike ETH-XGaze). On it,
the three tools are **within ~4° of each other (py-feat 20.0° ≤ OF3 21.3° ≤
LibreFace 23.7°)** — py-feat marginally best, none dominant. That is the honest
gaze result. The other four columns are each compromised:

**Reported (within-dataset) gaze — what each method claims on its home turf.**
These are the standard normalized-protocol numbers from each paper / training
repo (in-distribution: the model trained on that dataset's train split). They
are *not* directly comparable to our held-out cross-tool numbers above, but they
show the models' gaze is strong when evaluated the way the field reports it:

| Tool | MPII(Gaze) | Gaze360 | source |
|------|:---:|:---:|---|
| **py-feat v2.4** | **3.92°** | **6.81°** | au_deep v2.4 (deployed v24fix ckpt, weight-verified; in-distribution) |
| **OpenFace 3.0** | **2.56°** | 10.6° | OF3 paper (arXiv 2506.02891) |
| **L2CS-Net** (py-feat's gaze lineage) | 3.92° | 10.41° | L2CS paper (arXiv 2203.03339) |
| **LibreFace 2.0** | — | 14.68° | landmark-MLP, "Is Geometry Enough?" (arXiv 2603.24724) |

py-feat v2.4's gaze is **competitive with the published appearance-based
baselines on their own benchmarks** — MPIIGaze 3.92° (matching L2CS, vs OF3
2.56°) and Gaze360 6.81° (beating L2CS 10.41° and OF3 10.6°). LibreFace 2.0's gaze is a
**MediaPipe-landmark MLP** (not appearance-based), which it reports at 14.68° on
Gaze360 — weaker by design, consistent with it being last in our harness. (One
as-shipped detail, not a knock: the pip `get_facial_attributes`/`estimate_gaze`
returns LibreFace's *raw* gaze; the paper's bias correction (~+6.5° yaw / +5°
pitch) is **not** applied by the shipped API — so our end-to-end number reflects
what the software actually outputs, while the published table to the left shows
their corrected best case. This is the point of having both.)

The two tables answer different questions. **Reported (above):** each model on
its home dataset, normalized, best case — what it *can* do. **Measured
cross-tool (the main gaze table):** every model run end-to-end as shipped on
held-out data — what you *get*. The big measured numbers (20–44°) are the
out-of-distribution + cross-frame penalty, not weak models: in-distribution,
py-feat gaze is 4–7°. (As
a cross-check, our harness re-evaluating OF3 *outside* its normalized protocol
reproduced the same collapse — OF3 20.4° on MPIIGaze, 49.9° on Gaze360 vs its
paper's 2.56°/10.6°.)

Why each of the other columns is compromised:

- **Columbia & MPIIFaceGaze — py-feat overfit.** py-feat trained on *all* images
  of both, so its 2.7–2.8° is fitting its own training set, not generalization.
  (OF3 also trained on MPIIFaceGaze; Columbia is OF3's one out-of-sample set, at
  12°.) These cannot be read as a py-feat win.
- **Gaze360 — in-distribution for py-feat *and* OF3** (both trained on
  Gaze360-train; we score the held-out `bench` split). OF3's 41° is its shipped
  `detect→crop` not reproducing the normalized crop its head trained on (paper:
  10.6°) — a real pipeline limit, but it means the cell understates OF3's model.
- **ETH-XGaze — frame-mismatched against py-feat.** Its labels are in a
  head-*normalized* frame OF3 trained on (normalized MPII) but py-feat did not
  (Gaze360). Diagnostic: feeding py-feat's gaze head the patch directly (no
  re-crop) still gives MAE ~44° with **yaw correlation ≈0** against GT — so it's
  the frame, not the model. py-feat's L2CS also saturates at ±~40° pitch vs
  ETH-XGaze's ±75°. So 44.6° understates py-feat; the earlier "py-feat worse than
  OF3" read was withdrawn after this diagnostic.
- LibreFace gaze isn't a documented trained model (its paper is AU + expression);
  its 15–40° across sets is consistent with a geometric/landmark estimate.
- The Columbia loader yaw-sign convention was fixed in `feat.evaluation` as part
  of this work (had reported 17.5° from a sign mismatch; now 2.72°).

**Net:** on the only clean, frame-matched, out-of-sample gaze benchmark
(EYEDIAP), py-feat, OF3, and LibreFace are within ~4° (20.0/21.3/23.7°) — gaze is
roughly a wash, py-feat slightly ahead. The headline 2.7° "win" was overfitting;
the 44° "loss" was a frame artifact. The `train_status` column in `accuracy.csv`
flags in-sample / held-out / out-of-sample for every cell so no number is read as
clean when it isn't.

**How does ~20° compare to the literature?**

| EYEDIAP gaze | angular error | who |
|---|:---:|---|
| Published, **within-dataset** | ~5–6° | MAFI-Gaze 5.0°, RT-Gene 6.3° (gaze nets trained on EYEDIAP) |
| Published, **cross-dataset** (zero-shot) | ~8–10° | GMMGaze 8.1°, GazeNet 9.6° (gaze nets, not our tools) |
| **Our measured (end-to-end, held-out)** | **20.0 / 21.3 / 23.7°** | py-feat / OF3 / LibreFace |

None of our three tools report EYEDIAP in their papers (they report MPII/Gaze360),
so the published rows are general gaze-SOTA references. Our 20° is ~2× the
cross-dataset reference, for
three protocol reasons, not model failure: (1) we run **end-to-end on raw
camera frames with no gaze data-normalization** (every literature number applies
the Sugano/Zhang normalization — warp face to canonical pose/distance, predict
normalized gaze); (2) the **FT_S floating-target session** sweeps ±49° yaw / ±44°
pitch, wider than the screen-target sessions usually benchmarked; (3) these are
general-purpose facial-analysis tools, not dedicated cross-dataset gaze nets.
So the absolute number is higher than the normalized-protocol literature because
we measure **end-to-end as shipped** — that's the answer a user actually gets,
not a failure; the relative ordering is what holds.

**We ran the normalized-protocol pass too** (Sugano/Zhang data-normalization:
warp each face to a canonical virtual camera using EYEDIAP's head pose +
intrinsics, predict in the normalized frame — `shared/build_eyediap_normalized.py`).
It barely moved the numbers:

| Protocol | py-feat v2 | OpenFace 3.0 | LibreFace |
|---|:---:|:---:|:---:|
| camera-frame (raw crop) | 20.0° | 21.3° | 23.7° |
| **normalized** | **19.4°** | 21.5° | 28.1° |

py-feat stays marginally best under **both** protocols. Normalization didn't
help because **FT_S is a static-head session** — the head is already frontal, so
the normalization warp is near-identity. (It slightly hurt LibreFace, whose
landmark/geometric gaze dislikes the tight 448² crop.) So the ~20° is **robust,
not a frame artifact** — it's the genuine cross-dataset error of these
general-purpose tools on a wide-range floating-target session, ~2× the
gaze-specialist cross-dataset SOTA (~8–10°). The remaining gap would close with
EYEDIAP's screen-target (CS/DS) sessions (smaller gaze range) and dedicated
gaze nets — but the relative ordering (the three within a few °, py-feat ahead)
is stable across raw, normalized, and ETH-XGaze frames alike.

> Reproduce: `tools/<tool>/run_accuracy.py` (OF3/PyAFAR), `run_modalities.py`
> (LibreFace), `run_gaze.py` + `run_pyfeat_modalities.py` (py-feat). Consolidated
> by `ingest_accuracy.py` into `accuracy.csv`; published to the
> `py-feat/benchmarks` HF dataset.

## Speed

Throughput on the **shared test fixtures** (`single_face.mp4` video + a
`multi_face.jpg` image batch — *not* the accuracy datasets), each tool timed
end-to-end (detect → AU), across a hardware × batch matrix:

**Hardware:** CPU · RTX 3090 (sm_86) · RTX PRO 6000 Blackwell (sm_120) · Apple M5 (MPS)
**Batch:** 1 (single frame) and 16

**A blank cell is data.** If a tool can't run on a given device it gets *no
number* — that absence documents the tool's hardware reach. Expected coverage:

| Tool | CPU | 3090 | Blackwell | M5 (MPS) |
|------|:---:|:---:|:---:|:---:|
| **py-feat** | ✅ | ✅ | ✅ | ✅ |
| **OpenFace 3.0** | ✅ | ✅ | ? | ? |
| **LibreFace** | ✅ | ✅ | ❌ (no sm_120) | ? (cuda/cpu API) |
| **PyAFAR** | ✅? | ? | ❌ (dlib/CUDA) | ❌ (Ubuntu/WSL2 only) |

py-feat's own CPU/3090/Blackwell numbers are in the **[live dashboard](live.md)**
(e.g. Detectorv2 ≈ 285 fps on Blackwell batch 16); M5 is added from a Mac run.

**Methodology** (this matters — naive timing is misleading): every tool is timed
**end-to-end** (decode → detect → AU, the full pipeline it ships), on the **same
video** (`WolfgangLanger_Pexels.mp4`, 472 frames), with **warmup + 3 repeats**
(median reported) and `torch.cuda.synchronize()` around GPU work. Crucially, the
head-to-head is at **batch 1** — OpenFace 3.0 and LibreFace process per-frame
(their APIs don't expose batching), so comparing them to py-feat's batched
throughput would be apples-to-oranges.

**Head-to-head — RTX 3090, end-to-end, batch 1:**

| Tool | fps | vs py-feat |
|---|:---:|:---:|
| **py-feat Detectorv2** | **38.4** | — |
| **OpenFace 3.0** | 18.3 | 2.1× slower |
| **LibreFace** | 4.7 | 8.2× slower |
| **PyAFAR** | n/a | — |

**py-feat's batching is a separate advantage:** its `detect()` natively batches,
so Detectorv2 scales **38 → 202 fps** from batch 1 to 16 on the 3090. OF3 and
LibreFace have no batch path in their APIs (their *models* can batch, but the
shipped pipeline doesn't), so they stay at the per-frame rate. LibreFace's GPU
barely helps it at all — its MediaPipe alignment is CPU-bound and dominates.

The CPU / Blackwell / M5 cells need the same rigorous harness (folded into the
suite's `run_speed.py`); the earlier single-clip per-frame numbers there are
**not** trustworthy and were withdrawn. Hardware reach is still data: **OF3 runs
on Blackwell; LibreFace and PyAFAR cannot** (no sm_120 / dlib-CUDA).

The point of the matrix is exactly the blanks: py-feat is the only toolkit that
runs across CPU, current-gen GPUs, *and* Apple Silicon — and is one-to-two orders
of magnitude faster where competitors do run.

## Datasets & metric protocol — and why **DISFA+**, not DISFA

The cross-tool comparison runs on **DISFA+** (posed-peak, 12-AU intensity), the
held-out benchmark py-feat reports against (Cheong et al. 2023) and the dataset
our existing OpenFace 3.0 result already uses (`"dataset": "disfaplus"`).

**We deliberately do *not* evaluate on DISFA.** DISFA is the **training set** for
LibreFace (and is used by OpenFace 3.0), so scoring those tools on DISFA is
in-distribution — a home-field advantage and effective train/test contamination.
DISFA+ is held out for all tools, so it measures **generalization**: a tool that
only does well on its own training distribution is exactly what a fair benchmark
should expose. (We verified the in-distribution case as a *sanity check* — the
LibreFace RepVGG model tracks AU intensity cleanly on DISFA — then evaluate the
real comparison on DISFA+.)

Metrics: per-AU **PCC** (intensity, threshold-free — LibreFace's native metric)
and binary **F1** at intensity **≥ 2** on both prediction and ground truth
(matching `feat.evaluation.metrics`' truth convention). Where a tool emits
probabilities (py-feat, OF3) rather than intensities, its native binarization is
noted per table so protocols are never silently mixed.

## Per-tool integration experience

### py-feat (v1 / v2)
`pip install py-feat`; one call returns AUs (+ emotion, pose, gaze, landmarks,
identity). Runs on CPU, CUDA (incl. **Blackwell / RTX PRO 6000**, sm_120, on
torch 2.11+cu128), and Apple MPS. No per-tool preprocessing to match.

### LibreFace — could **not** reproduce published numbers locally
A multi-day saga that is worth recording in full:

1. **The pip API (`libreface.get_facial_attributes`) collapses on this data.**
   Its `au_intensities` are near the noise floor for clearly-active AUs — e.g.
   a DISFA+ frame labeled AU12 intensity 4 (a posed smile) returns
   `au_12 ≈ 0.015` (it correctly returns ~2.5 on a normal smiling photo).
   No threshold/normalization recovers a signal that isn't there.
2. The LibreFace **paper** reports DISFA AU *intensity* via **PCC** (0.63) from a
   **separate research module** (`AU_Recognition`, RepVGG checkpoint), not the
   distilled all-in-one pip model. So we cloned the repo and loaded
   `new_checkpoints_fm_repvgg/DISFA/all/repvgg.pt` (output `×5 → [0,5]`).
3. **The research checkpoint can't run on Blackwell.** LibreFace pins an old
   PyTorch built for **sm_37…sm_86**; Blackwell is **sm_120**. Weights copy to
   the GPU ("loaded"), then the first compute kernel aborts (no sm_120 binary).
   **LibreFace is therefore restricted to ≤ Ampere GPUs** — we benchmark it on
   the RTX 3090 (sm_86). py-feat runs on Blackwell unchanged.
4. **It is fragile to out-of-distribution data and alignment.** On **DISFA+**
   (posed-peak) the research checkpoint *also* collapsed (AU12 ramp 0→4 stayed
   ~0.1–0.5, non-monotonic) — under both LibreFace's own MediaPipe alignment and
   DISFA+ native `Aligned/` crops. It only works on **DISFA itself**, fed
   **DISFA's own aligned crops** (`DISFA_/aligned/...`): there the AU12 ramp is
   clean and monotonic — GT 0→0.05, 1→~0.5, 2→~1.2, 3→~2.7, 4→~3.5, 5→~4.4.

**Status:** the research RepVGG checkpoint runs correctly. On the held-out
**DISFA+** set (its own aligned crops, LibreFace's test transform, 57,150 frames)
it generalizes reasonably: **mean F1 = 0.46, mean PCC = 0.73** over 12 AUs
(`run_libreface_repvgg_disfaplus.py` → `libreface_repvgg_disfaplus.json`).
Strong on AU25 (F1 0.91), AU04/09 (0.75); weak on AU06 (0.11), AU15/17/20
(~0.06). Note: earlier single-frame probes suggested a "collapse" — that was an
artifact of unrepresentative frames and the broken *pip* model; the full-dataset
research-model run is the truth, and it's fine. (The lesson — over-concluding
from a handful of frames — is why we report the whole-benchmark output.)

Getting even this far required: discovering the pip model is a different
(weaker) net than the paper's, cloning the research repo + checkpoints, working
around a Blackwell-incompatible torch (3090-only), and matching the alignment —
vs. py-feat's `pip install` + one call. The silent failure modes (pip-model
collapse, out-of-distribution collapse) are themselves the usability story:
without careful per-frame validation you'd ship wrong numbers.

### OpenFace 3.0
Cleaner to install than LibreFace/PyAFAR (`pip install openface-test` +
`openface download`), but the shipped pip CLI has **three blocking bugs**:
1. A **hardcoded developer path** baked into the STAR landmark config
   (`ckpt_dir = '/work/jiewenh/openFace/OpenFace-3.0/STAR'`) → `Permission
   denied: '/work'` on any other machine until patched.
2. `openface detect-video` throws an **OpenCV `imread` error** (mishandles video
   frames) — video mode is unusable.
3. `openface ... -d cuda` always raises *"provide at least one valid device
   ID"* — the CLI never passes `device_ids`, so **GPU mode is broken** from the
   CLI.

Critically, **the CLI also hardcodes `device='cpu'`** inside `process_image`
(line 23) — so `openface detect -d cuda` silently runs on CPU. The fix is to
**bypass the CLI** and construct the pipeline objects directly with real device
handling: `FaceDetector(device='cuda')`, `LandmarkDetector(device='cuda',
device_ids=[0])`, `MultitaskPredictor(device='cuda')`. Done that way OF3 runs
fine on GPU **including Blackwell** (modern torch).

Once the CLI is bypassed, OF3 is solid: AU accuracy on DISFA+ **0.488** (8 AUs)
and end-to-end speed **18.3 fps** on the 3090 (batch 1, rigorous harness —
warmup + repeats, median). So OF3 is the *least* broken competitor — it just
needs the CLI worked around. (The running, once set up, is reliable — the
friction is all in packaging.) Note its **MTL AU model batches fine** (the model
takes `[B,…]`; the shipped pipeline just feeds one face at a time), so OF3 *could*
be sped up with a custom batched runner — its API simply doesn't.

### PyAFAR — dependency rot + API/coverage mismatch
Another multi-obstacle integration (its own MediaPipe + TensorFlow env, kept
away from the torch stack):

1. **Won't `pip install`.** The release wheel pins `pysimplegui==4.60.5`, a GUI
   library that PySimpleGUI **pulled from PyPI** (2024 licensing change), so the
   dependency is unsatisfiable — a GUI pin blocks a headless benchmark. Workaround:
   install the wheel `--no-deps` and hand-resolve the real runtime deps
   (`tqdm`, `scipy`, `h5py`, `tensorflow`, `mediapipe`, `opencv`, …) one ImportError
   at a time.
2. **dlib won't build.** `pip install dlib` compiles from source and fails on its
   **CUDA** kernels (same Blackwell sm_120 wall); the documented path is a **conda**
   env with conda-forge's precompiled dlib.
3. **Video-only API.** `adult_afar(filename=<video>, …)` takes a video file —
   DISFA+ is per-frame stills, so frames must be re-assembled into per-trial
   videos to feed it.
4. **Partial AU coverage.** Its occurrence AUs {1,2,4,6,7,10,12,14,15,17,23,24}
   overlap DISFA's 12 on only **7** (1,2,4,6,12,15,17); intensity on **3**
   (6,12,17). It cannot score the full DISFA AU set.
5. Non-commercial license; GPU only on Ubuntu/WSL2.

Contrast: py-feat is one `pip install`, works headless, takes images or video,
and reports all 20 AUs.

**Resolved (the friction was the result).** We did get PyAFAR running: a conda
env rebuilt to its *own* declared stack (`tensorflow==2.12`, a working
`mediapipe.solutions`, `numpy<2`, matching protobuf/opencv — the shipped combo
was internally inconsistent), `download_models`, plus a frame→per-trial-video
adapter for its video-only API. Run unmodified over all 57,150 DISFA+ frames it
scores **mean F1 0.26 on its 7 overlapping AUs** (AU06 0.61, AU12 0.55; AU01/04
≈0), and cannot predict 5 of the 12 DISFA AUs at all. Every obstacle above had
to be cleared just to get that partial number — the contrast with py-feat's one
`pip install` stands.

## Hardware notes

- **LibreFace can only be benchmarked on ≤ Ampere GPUs (e.g. RTX 3090, sm_86)**
  because its pinned PyTorch lacks Blackwell (sm_120) kernels. All LibreFace
  numbers here are 3090 runs.
- py-feat and the competitor runs that use modern torch run on Blackwell
  (RTX PRO 6000) and the 3090 alike.

## License caveats (research benchmark only)

- LibreFace: USC research-only. PyAFAR: non-commercial. OpenFace 3.0: check its
  license. py-feat's competitors are **never** added as py-feat dependencies —
  each runs in its own isolated env (`~/benchmark-envs/<tool>`), consuming a
  frozen DISFA manifest (`scripts/competitors/`) so the comparison shares
  identical frames/labels without coupling envs.

## Reproducing

- Manifest (py-feat env): `scripts/competitors/export_disfaplus_manifest.py`
  (DISFA equivalent forthcoming).
- LibreFace research model: clone `ihp-lab/LibreFace`, use `AU_Recognition`
  RepVGG checkpoint, **on a 3090**.
- py-feat v1/v2 accuracy: `scripts/bench_accuracy.py --detector v1|v2`.