File size: 8,827 Bytes
96f131c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
---
license: cc-by-4.0
language:
- en
- zh
pretty_name: PaceSI
size_categories:
- 1K<n<10K
tags:
- speech-translation
- speech-to-speech-translation
- simultaneous-translation
- simultaneous-interpretation
- speaking-rate
- evaluation
- audio
task_categories:
- translation
- automatic-speech-recognition
configs:
- config_name: en_fast
  data_files:
  - split: test_sent
    path: data/en_fast/test_sent.parquet
  - split: test_full
    path: data/en_fast/test_full.parquet
- config_name: en_slow
  data_files:
  - split: test_sent
    path: data/en_slow/test_sent.parquet
  - split: test_full
    path: data/en_slow/test_full.parquet
- config_name: zh_fast
  data_files:
  - split: test_sent
    path: data/zh_fast/test_sent.parquet
  - split: test_full
    path: data/zh_fast/test_full.parquet
- config_name: zh_slow
  data_files:
  - split: test_sent
    path: data/zh_slow/test_sent.parquet
  - split: test_full
    path: data/zh_slow/test_full.parquet
---

# PaceSI: fast and slow talks for simultaneous speech-to-speech translation

Speakers do not all talk at the same speed. When a speaker is fast, a simultaneous speech-to-speech translation
system has to keep up and not fall behind. When a speaker is slow, it has to follow that slow pace without long,
awkward pauses in its own speech. PaceSI is a test set that measures how well a system does both.

It contains 16 single-speaker YouTube talks, 8 in English and 8 in Chinese. In each language, 4 talks are fast
and 4 are slow. The speed is the speaker's own: no audio was sped up or slowed down. Each talk comes with
its full audio, a transcript, sentence timing and a translation into the other language, verified by human
annotators.

| Subset | Direction | Talks | Sentences | Audio | Speaking rate |
|---|---|---|---|---|---|
| `en_fast` | English → Chinese | 4 | 778 | 57.8 min | 270 words per minute |
| `en_slow` | English → Chinese | 4 | 337 | 45.1 min | 142 words per minute |
| `zh_fast` | Chinese → English | 4 | 644 | 54.9 min | 392 characters per minute |
| `zh_slow` | Chinese → English | 4 | 345 | 53.8 min | 162 characters per minute |

The speaking rate counts only the time inside sentences, so pauses between sentences do not lower it.

## Quick start

There are four subsets (`en_fast`, `en_slow`, `zh_fast`, `zh_slow`), and each has two splits:

- **`test_sent`**: one row per sentence, with the audio of that sentence.
- **`test_full`**: one row per talk, with the whole audio and all its sentences.

```python
from datasets import load_dataset

REPO = "Open-LiveTranslate/PaceSI"

# Sentence level
sent = load_dataset(REPO, "en_fast", split="test_sent")
row = sent[0]
row["source"]        # "What's going on, everybody?"
row["translation"]   # "大家好,最近怎么样?"
row["audio"]         # the audio of this sentence, 16 kHz mono

# Talk level
full = load_dataset(REPO, "en_fast", split="test_full")
talk = full[0]
talk["audio"]        # the whole talk, 16 kHz mono
talk["sentences"]    # every sentence: idx, start, end, source, translation, reference_origin
talk["source"]       # the whole transcript, one sentence per line
talk["translation"]  # the whole reference, one sentence per line, line-aligned with the transcript
```

With `datasets` 4 or newer, `row["audio"].get_all_samples()` returns the samples and the sample rate
(it needs the `torchcodec` package).

## How to evaluate with it

The set is made for **simultaneous speech-to-speech translation** of long audio. It also works for simultaneous
speech-to-text translation, offline speech translation and speech recognition.

1. Use the `test_full` split. Give your system the whole audio of a talk, the way it would hear a live talk. Do not
   cut it into sentences first.
2. Align the system output to the `sentences` of that talk.
3. Score quality against each sentence's `translation`, and latency against its `start` and `end` time.
4. Report the fast and the slow subset as separate numbers. The gap between them is the point of this set.

Use the `test_sent` split when you want sentence-level input, for example for offline translation or recognition.

The `files/<subset>/` folders hold the same data as plain files, laid out like an ACL 60/60 evaluation root
(`dev.yaml`, `dev/full_wavs/`, `dev/text/txt/`), so tools that read that layout can use them as they are.

## Dataset structure

### Fields

Both splits have the same columns.

| Field | In `test_sent` (one sentence) | In `test_full` (one talk) |
|---|---|---|
| `id` | talk id plus sentence number, such as `M2ySRYpo9S0_0000` | the talk id |
| `talk` | YouTube video id of the talk | the same |
| `speed` | `fast` or `slow` | the same |
| `audio` | audio of the sentence, 16 kHz mono | audio of the whole video, 16 kHz mono |
| `start`, `end` | time of the sentence in the talk, in seconds | 0 and the length of the talk |
| `source` | transcript of the sentence, as spoken (fillers and repeats are kept) | the whole transcript, one sentence per line |
| `translation` | reference translation of the sentence | the whole reference, one sentence per line |
| `reference_origin` | how far a human annotator checked this reference (see below) | empty |
| `sentences` | empty | list of every sentence: `idx`, `start`, `end`, `source`, `translation`, `reference_origin` |

The reference is in Simplified Chinese for English talks and in English for Chinese talks.

### Files

```
data/<subset>/test_sent.parquet    the sentence-level split, audio inside
data/<subset>/test_full.parquet    the talk-level split, audio inside
files/<subset>/                    the same data as plain files
  sentences.jsonl                  one sentence per line (no audio)
  dev/full_wavs/<video id>.wav     16 kHz mono 16-bit, the whole video's audio
  dev.yaml                         one entry per sentence: offset and duration in the talk's audio
  dev/text/txt/PaceSI.<subset>.<lang>.txt   transcript and reference, one sentence per line, line-aligned with dev.yaml
  dev/TALKS.tsv, dev/FILE_ORDER    talk order and sentence counts
  build_info.json                  counts and the sha256 of every file
ATTRIBUTION.tsv                    channel, title, link, upload date and licence of every talk
```

## How it was built

1. **Talks.** We searched YouTube for talks with one speaker, the Creative Commons Attribution licence on
   the watch page, audio owned by the channel, and a length of 5 to 60 minutes. Several human annotators listened and judged
   whether each speaker is fast or slow.
2. **Transcripts and times.** A draft came from Qwen3-ASR, with sentence times from Qwen3-ForcedAligner. Human annotators
   then checked every sentence against the audio and fixed the words and the start and end times.
3. **References.** Each talk was translated by gpt-6-sol with the whole talk as context. A GEMBA-ESA judge
   (gpt-6.1-sol) scored every line from 0 to 100. Human annotators post-edited every line that scored under 100. A last check
   that read whole talks sent 44 more lines back to a human annotator.

### How far each reference was checked

| `reference_origin` | Meaning | en_fast | en_slow | zh_fast | zh_slow |
|---|---|---|---|---|---|
| `post_edited` | A human annotator changed the machine translation | 86 | 57 | 71 | 23 |
| `human_checked` | A human annotator read it and kept it | 450 | 51 | 453 | 109 |
| `judge_passed` | The judge gave 100; no human annotator read it line by line | 242 | 229 | 120 | 213 |

## Limitations

- **The references are post-edited machine translation, not human translation.** References made by a GPT model
  may favour GPT-like systems in metrics such as BLEU and COMET.
- **Small.** 16 talks and 16 speakers. Use it to compare fast and slow speech, not to rank systems in general.
- **Times.** Neighbour sentences can overlap by a few tenths of a second, and a few sentence borders come from the
  aligner's word times and were not checked by ear.
- **Chinese text is in simplified characters**, also for speakers from Taiwan and Malaysia.

## Licence

- **Our work is CC BY 4.0**: the transcripts, the sentence times and the translations.
- **The audio stays under the licence its channel gave it.** Every talk was published on YouTube under the Creative
  Commons Attribution licence. The version follows YouTube's Creative Commons option at upload time: CC BY 3.0 for
  videos uploaded before 2025-08-01 and CC BY 4.0 after. `ATTRIBUTION.tsv` lists the channel, title, link, upload
  date, licence text, licence version and the date we checked each page.
- **If you use the audio**, credit the channel with the title and link, name the licence, and say what was changed.
  We changed the audio only by extracting it from the video and converting it to 16 kHz mono.

Please do not use the audio for speaker identification or voice cloning.