---
language: en
task_categories:
  - other
---

# ELLSA 2 — Data Selection and Dialogue Gesture Benchmark

ELLSA 2 studies coordinated speech, gestures, and facial expressions in full-duplex conversation. Its data pipeline selects informative speaking/listening motion, prepares facial supervision, and evaluates communicative behavior using human-verified examples.

This dataset releases **data selection/preparation and the dialogue test set**. Model training, inference and evaluation implementations are in the sibling code package.

## Contents

| Path | Contents |
| --- | --- |
| `testset/` | ELLSA 2 dialogue gesture benchmark, 67 duplex and 71 semantic clips |
| `manifests/train_all_resolved.json` | Full source pool: 121,054 aligned target/partner recordings, with portable paths |
| `manifests/train_selected81.json` | Selected inventory of 1,318 recordings from 81 speakers |
| `manifests/selected_speakers.json` | Selected speaker IDs |
| `manifests/speaker_quality.csv` | Speaker-level quality statistics |
| `selection_protocol.json` | Original normalization, thresholds, and selection rules |
| `preprocess/` | Scripts for speaker selection and facial extraction |

Each benchmark clip includes aligned target/partner audio, 600-frame SMPL-H and facial ground truth, a separate 612-frame nonoverlapping style clip, transcripts/VAD and reference video. The style pose in `testset/style/` is paired with a raw 108D FLAME reference in `testset/style_flame/`; the manifest and prepared inference jobs include both. Keep the packages as sibling `data/`, `code/`, and `checkpoints/` directories, or use `ELLSA2_DATA_ROOT` and `ELLSA2_CHECKPOINT_ROOT` when running the code package.

## Setup

All commands below run from this data directory. Speaker selection can run without the ELLSA2 model package or PyTorch:

```bash
python -m pip install -r requirements.txt
```

KaoLRM extraction uses its own GPU environment. RVQ token caching uses the model environment described in the [code guide](../code/README.md#installation).

## Use ELLSA2 dialogue gesture benchmark

Create inference and rendering jobs:

```bash
python preprocess/prepare_testset.py --output-dir outputs/test
# Select one included clip:
python preprocess/prepare_testset.py --test-id fro_00038 --output-dir outputs/example
```

To run the Standalone generator, switch to the code directory:

```bash
cd ../code
python infer.py --model-path ../checkpoints/standalone_generator --test-id fro_00038 --output-dir outputs/example
```

## Prepare the selected training inventory

The included `manifests/train_selected81.json` is the training input: **1,318 recordings from exactly the 81 IDs in `manifests/selected_speakers.json`**. Each row contains pose, target audio, partner audio, transcript paths and one raw facial-label field, `flame_file`.

Download the original [Seamless Interaction dataset](https://huggingface.co/datasets/facebook/seamless-interaction) using its [official download guide](https://github.com/facebookresearch/seamless_interaction), including person videos (`.mp4`), SMPL-H poses (`.npz`), audio and transcripts. Preserve its `naturalistic/train/` and `improvised/train/` hierarchy. **The original dataset has no FLAME files. Extract the raw facial labels below before creating training links.** Speaker selection has already been performed for this inventory; the separate [speaker-selection workflow](#speaker-selection) is only needed to replay or change that selection.

The manifest expects 16 kHz mono `<recording>_16k.wav` files for both participants. Convert the selected original WAVs before linking them; existing outputs are retained:

```bash
conda install -c conda-forge 'ffmpeg>=6=gpl_*' --freeze-installed -y
python preprocess/prepare_audio.py --dataset-root /path/to/seamless_interaction
```

### Extract raw facial labels

The parameter-only KaoLRM entry point estimates facial labels from source-person video crops on the **30 Hz body timeline**. Create a separate extraction environment:

```bash
conda create -n ellsa2_kaolrm python=3.12 pip -y
conda activate ellsa2_kaolrm
python -m pip install -r preprocess/requirements-kaolrm.txt
```

Resolve the selected inventory against your download, then extract labels.

```bash
python preprocess/resolve_paths.py \
  --input manifests/train_selected81.json \
  --dataset-root /path/to/seamless_interaction \
  --output outputs/extraction_input.json

python preprocess/extract_kaolrm.py \
  --input outputs/extraction_input.json \
  --checkpoint ../checkpoints/external_assets/kaolrm-mono \
  --output-dir outputs/flame_raw \
  --output-manifest outputs/train_raw.json \
  --device cuda:0
```

The extractor writes one `<pose_stem>_flame.npz` per recording into `outputs/flame_raw/`, and an absolute-path training manifest into `outputs/train_raw.json`. Use `--max-videos 2 --max-frames 96` for a small check, with a separate output directory.

### Link source data and extracted labels

After the complete extraction finishes:

```bash
python preprocess/link_training_data.py \
  --dataset-root /path/to/seamless_interaction \
  --flame-root outputs/flame_raw
```

This creates `source/seamless_interaction/` under the data package. Audio, poses and transcripts link to the downloaded dataset; `flame_file` links to the newly extracted flat output directory.

Training can now use the included `manifests/train_selected81.json` unchanged, as described in the [training guide](../code/README.md#training).

## Speaker selection

The included `manifests/train_all_resolved.json` supplies the **121,054-recording source pool** used for the speaker quality statistics. Its paths are portable `data/source/seamless_interaction/...` references; `--dataset-root` maps them to your downloaded files.

### 1. Score 60-second windows

```bash
python preprocess/build_stageA_quality_data.py \
  --input-json manifests/train_all_resolved.json \
  --dataset-root /path/to/seamless_interaction \
  --output-json outputs/train_quality.json \
  --output-windows-jsonl outputs/quality_windows.jsonl \
  --output-speaker-csv outputs/speaker_quality_new.csv \
  --target-sec 60 --stride-sec 30 --num-workers 4
```

The default scale uses source-pool quantiles frozen in `selection_protocol.json`. Use `--recompute-normalization` only when fitting a replacement full-pool scale. If you already have an absolute-path `train_all_resolved.json`, pass it directly and omit `--dataset-root`.

| Quality component | Weight |
| --- | ---: |
| Motion validity | 0.12 |
| Smoothness | 0.10 |
| Natural range | 0.10 |
| Motion energy | 0.32 |
| Speech-motion compatibility | 0.30 |
| Visibility | 0.06 |

### 2. Select speakers

Replay the released selection from the frozen quality CSV without rerunning window scoring:

```bash
python preprocess/build_stageA_select_spk.py \
  --input-speaker-csv manifests/speaker_quality.csv \
  --input-data-json manifests/train_all_resolved.json \
  --output-speaker-csv outputs/selected_speaker_quality.csv \
  --output-json outputs/train_selected.json \
  --min-pass-rate 0.7 --min-mean-score 0.9 \
  --min-mean-speech-motion-score 0.9 --max-outlier-rate 0.01 \
  --min-windows 1 --min-passed 1
```

These thresholds retain speakers with pass rate ≥ 0.70, mean quality ≥ 0.90, mean speech-motion compatibility ≥ 0.90, outlier rate ≤ 0.01, and at least one assessed/passing window.

## License and distribution

Authored preprocessing code retains [Apache-2.0](LICENSE). Dataset, source components, and weights retain their upstream terms. KaoLRM components include their [source license](preprocess/vendor/kaolrm/LICENSE.txt), [NVIDIA license](preprocess/vendor/kaolrm/LICENSE_NVIDIA.txt), and [weight license](preprocess/vendor/kaolrm/LICENSE_WEIGHT.txt).