AVCC is 29 unscripted English conversations from YouTube and Twitch, filmed with one static camera, with 2 or 3 people on screen. Every segment has word-level transcripts with speaker labels, utterances, RTTM and per-frame face boxes. The test videos also come with hold/shift turn events.

AVCC was introduced in our Interspeech 2026 paper (MuVAP, see Citation below).

Path	What it is
`videos/<videoID>/<seg>.mp4`	video segments (see Download)
`word/<videoID>/<seg>.txt`	one row per word, with speaker and timing
`utterance/<videoID>/<seg>.txt`	words joined into utterances
`rttm/<videoID>/<seg>.rttm`	who speaks when, one row per utterance
`bbox/<videoID>/<seg>.csv`	face box of each speaker, per video frame
`splits.txt`	train / val / test for each video
`test_events.txt`	hold and shift events on the test set
`human_eval.csv`	human answers on the test events (who speaks next)
`script/`	tools: rebuild utterance/rttm, extract face crops and audio, viewer, annotation tool

A segment is a stretch of a video with no cuts or edits. Segments run from 20 s to about 72 min (median 2 min). All times are in seconds from the start of the segment.

Download

AVCC is on Hugging Face: https://huggingface.co/datasets/Haotian-Qi/AVCC

Request access on that page with your name, email, institution or company and what you will use the data for. AVCC is for non-commercial use only. Once you have access:

hf auth login
hf download Haotian-Qi/AVCC --repo-type dataset --local-dir AVCC
python3 AVCC/script/unzip_videos.py --delete-zips

The videos (about 21 GB) are downloaded as two zips into videos_zip/, which is only a holding folder. The script checks the zips, unpacks every video to videos/<videoID>/<seg>.mp4 and deletes the zips. It ends by listing any segment that still has no video.

The videos are 25 fps H.264, mostly 1920x1080 (13 segments are 1280x720), with AAC audio at 44.1 kHz, stereo.

Splits

The split is by video, so no conversation appears in more than one split.

Split	Videos	Segments	Hours	Words	Utterances
train	17	258	20.6	230,071	42,653
val	5	54	2.7	30,820	5,556
test	7	96	7.7	95,697	16,071
total	29	408	31.0	356,588	64,280

splits.txt is tab-separated with a header: videoID, split.

Speakers

Speakers are labelled 0, 1 and 2. The same label is used for a person in word, utterance, rttm and bbox of the same segment, so you can match a voice to a face. 217 segments have two people on screen and 191 have three.

B is someone you can hear but who is not one of the people on screen, for example a person behind the camera. B has no face box. It covers 608 words in 22 segments. We leave B out when scoring.

In a few segments a person is on screen the whole time but never says anything. They still have a face box.

Words

word/<videoID>/<seg>.txt, tab-separated, no header, sorted by start time:

videoID  seg  speaker  start  duration  word
-2bb2zIhoRw	seg01	1	0.417	0.214	I
-2bb2zIhoRw	seg01	1	0.631	0.290	felt

Times have 3 decimals. The words were transcribed and force-aligned automatically, then checked and corrected by hand, both the text and the speaker. Spelling follows normal English, with fillers written as they sound (um, uh, mhm).

Two tags are used in place of words:

Tag	Meaning	Count
`[unk]`	someone is talking but the words can't be made out	305
`[foreign]`	speech in a language other than English	60

A tag keeps the speaker and timing of that stretch of speech and counts as speech in utterance/ and rttm/. Laughter, breathing and other non-speech sounds are not transcribed.

Utterances and RTTM

utterance/<videoID>/<seg>.txt has the same columns as word/, with the text of the utterance in the last column. A speaker's words are joined into one utterance as long as the pause between two words is 0.1 s or less. Other people talking during that pause does not split it.

rttm/<videoID>/<seg>.rttm is standard RTTM, one row per utterance. The file ID is <videoID>+<seg>:

SPEAKER -2bb2zIhoRw+seg01 0 0.417 1.974 <NA> <NA> 1 <NA> <NA>

Both are generated from word/. To rebuild them, for example after editing words or to try another pause length:

python3 script/make_utterance_rttm.py        # 0.1 s
python3 script/make_utterance_rttm.py 0.2    # any other pause, in seconds

Face boxes

bbox/<videoID>/<seg>.csv, comma-separated, with a header:

frame_idx,speaker_id,x1,y1,x2,y2
0,0,284,239,489,517

frame_idx starts at 0 (time = frame_idx / 25). x1,y1 is the top-left corner and x2,y2 the bottom-right corner, in pixels of the video frame. There is one row per person per frame. If a person has no row for a frame, their face was not visible or not found there.

Faces were detected and tracked with InsightFace (RetinaFace), the tracks were assigned to speakers with ArcFace embeddings, and the result was checked and corrected by hand.

Turn events (test set)

test_events.txt, tab-separated, no header, one row per event:

videoID  seg  prev_speaker  start  duration  next_speaker  type
6YMeBNcRbS8	seg02	0	1.530	0.276	1	shift

Each event is a pause between two words. prev_speaker said the last word before it and next_speaker the first word after it. The type is hold when they are the same person and shift when they are not. start is 0.1 s after the last word ends, and the event ends when the next word starts, so the pause is between 0.2 s and 3 s long. Nobody else talks during the event, except in 3 events where a short word from another person runs into the start.

There are 1,730 events in the 7 test videos: 865 hold and 865 shift.

Human evaluation

human_eval.csv has the answers from the human study in the paper. Participants watched a test clip up to a turn event and picked who would speak next. 154 people (recruited on Prolific and through personal contacts) gave 4,290 answers, mostly 29 or 30 each, covering all 1,730 events.

Column	Meaning
`participant_id`	anonymous code, e.g. `H001`
`role`, `channel`	always `main`; `prolific` or `personal`
`english_proficiency`	`native`, `near_native` or `advanced`, self-reported
`event_id`	`<type>-<videoID>-<seg>-<start>`, the matching row of `test_events.txt`
`event_type`, `video_id`	`hold` or `shift`, and the video
`n_speakers`, `n_faces_visible`	people in the segment, and faces on screen at the event
`previous_speaker`, `gold_next_speaker`	as in `test_events.txt`
`choice`	the speaker they picked, or `__SKIP__`
`hold_shift_choice`	`hold` if they picked the previous speaker, otherwise `shift`
`correct_identity`, `correct_hold_shift`	1 or 0, empty when skipped
`confidence`	1 (low) to 5 (high)
`decision_time_ms`, `replay_count`, `answered_at`	time to answer, replays, and when

Speaker labels follow the corrected annotations, so they match test_events.txt and the face boxes. Overall, people picked the right next speaker 59.8% of the time and the right hold or shift 64.5% of the time.

Tools

Everything in script/ runs from the dataset folder with Python 3. Only extract.py needs extra packages (pip install -r script/requirements.txt); the rest use the standard library, and annotate.py also calls ffmpeg for the audio track.

Script	What it does
`unzip_videos.py`	checks the downloaded zips and unpacks them into `videos/`
`make_utterance_rttm.py`	rebuilds `utterance/` and `rttm/` from `word/`
`extract.py`	face crops, audio and model windows, as raw files or webdataset shards
`viewer.py`	browse any segment: video with face boxes, words, utterances, turn events
`annotate.py`	edit words, speakers and face boxes, then save

Viewer and annotation tool both open in the browser:

python3 script/viewer.py      # http://127.0.0.1:8780
python3 script/annotate.py    # http://127.0.0.1:8781

The viewer never writes anything. The annotation tool saves words to word/, rebuilds that segment's utterance/ and rttm/ files, and saves boxes to bbox/. Press ? in it for the keyboard shortcuts.

extract.py prepares model inputs the same way MuVAP does: 112x112 grayscale face crops per speaker and frame (a square around the box, grey where there is no box), 16 kHz mono audio, and per-frame speaking labels from rttm/, cut into MuVAP's windows (train: 30 s every 20 s; val: 30 s tiles with 2 s of context; test: the 10 s before each turn event). It needs ffmpeg.

python3 script/extract.py --out OUT                 # webdataset tar shards, one sample per window
python3 script/extract.py --out OUT --format raw    # images, wav and csv files per segment

The raw output also keeps the original audio track as orig_audio/. Crops are grayscale 112x112 by default; --color rgb keeps the original colours (RGB order in the .npy arrays) and --size sets another side length, for example --color rgb --size 224. Use --split, --video and --seg to extract part of the data, --workers to run in parallel, and --help for the rest.

Citation

If you use AVCC, please cite:

@inproceedings{qi26_interspeech,
  title     = {{MuVAP: Multimodal Multiparty Voice Activity Projection for Turn-taking Prediction in the wild}},
  author    = {Haotian Qi and Gabriel Skantze},
  year      = {2026},
  booktitle = {{Interspeech 2026 [Long Track]}},
  pages     = {5952--5961},
  doi       = {10.21437/Interspeech.2026-1381},
  issn      = {2958-1796},
}

License

The annotations (word, utterance, rttm, bbox, splits.txt, test_events.txt, human_eval.csv) are released under CC BY-NC 4.0 (https://creativecommons.org/licenses/by-nc/4.0/): you may use, share and adapt them with credit, but not for commercial purposes. The code in script/ is MIT.

We do not own the videos. They come from publicly available YouTube and Twitch content, and the copyright stays with the people who made them. They are shared for non-commercial research only. Please do not redistribute them or use them to identify the people in them. If you appear in a video or own one and want it taken out, email us and we will remove it.

Contact

Haotian Qi, KTH Royal Institute of Technology: haotianq@kth.se

Downloads last month: 57

Total file size:

22.5 GB

You need to agree to share your Hugging Face information to access this dataset

AVCC: Audio-Visual Conversation Corpus

Contents