anyreach-ai/dualturn-otospeech-turn-taking

OtoSpeech Turn-Taking

Processed version of the OtoSpeech corpus with per-frame turn-taking labels and Mimi speech codec features. Each row is one full conversation.

Splits

Split	Sessions
train	900
val	112
test	113

80/10/10 split, seed=42.

Features

Column	Shape	dtype	Description
session_id	—	str	Unique session identifier
dataset	—	str	Source corpus name
duration_s	—	float	Conversation duration (seconds)
codes_ch0	[T, 8]	int	Mimi RVQ codes, speaker 0
codes_ch1	[T, 8]	int	Mimi RVQ codes, speaker 1
mimi_feat_ch0	[T, 512]	float	Mimi continuous embeddings, speaker 0
mimi_feat_ch1	[T, 512]	float	Mimi continuous embeddings, speaker 1
vad_ch0	[T]	float	Voice activity (0/1), speaker 0
vad_ch1	[T]	float	Voice activity (0/1), speaker 1
eot_ch0	[T]	int	End-of-Turn label, speaker 0
eot_ch1	[T]	int	End-of-Turn label, speaker 1
hold_ch0	[T]	int	Hold (no handover) label, speaker 0
hold_ch1	[T]	int	Hold (no handover) label, speaker 1
bot_ch0	[T]	int	Beginning-of-Turn label, speaker 0
bot_ch1	[T]	int	Beginning-of-Turn label, speaker 1
bc_ch0	[T]	int	Backchannel label, speaker 0
bc_ch1	[T]	int	Backchannel label, speaker 1
fvad_ch0	[T, 4]	float	Fine-grained VAD logits (4 heads), speaker 0
fvad_ch1	[T, 4]	float	Fine-grained VAD logits (4 heads), speaker 1

Frame rate: 12.5 Hz — 1 frame = 80 ms. Event labels (eot, hold, bot, bc) are sparse binary: 0 everywhere except at event frames.

Splits file

splits.json in the repo root maps every session ID to its split. Useful for reproducing the split or processing the raw audio yourself:

from huggingface_hub import hf_hub_download
import json

path = hf_hub_download("anyreach-ai/dualturn-otospeech-turn-taking", "splits.json", repo_type="dataset")
with open(path) as f:
    splits = json.load(f)

print(splits["split_counts"])
# e.g. {'train': 900, 'val': 112, 'test': 113}

Loading

import numpy as np
from datasets import load_dataset

ds = load_dataset("anyreach-ai/dualturn-otospeech-turn-taking")

session = ds["val"][0]
T = session["num_frames"]

# 2D arrays are stored flat — reshape to recover original shape
codes = np.array(session["codes_ch0"]).reshape(T, 8)      # (T, 8)   int
feats = np.array(session["mimi_feat_ch0"]).reshape(T, 512) # (T, 512) float
fvad  = np.array(session["fvad_ch0"]).reshape(T, 4)        # (T, 4)   float

# 1D arrays — use directly
vad = np.array(session["vad_ch0"])   # (T,) float
eot = np.array(session["eot_ch0"])   # (T,) int

PyTorch windowed loader

import numpy as np
import torch
from torch.utils.data import DataLoader
from datasets import load_dataset

LABEL_KEYS = ["eot", "hold", "bot", "bc"]

def collate_windows(sessions, window_frames=125, hop_frames=25):
    """Slice each session into fixed-length windows and collate into a batch."""
    windows = []
    for s in sessions:
        T = s["num_frames"]
        codes = np.array(s["codes_ch0"]).reshape(T, 8)
        for start in range(0, T - window_frames + 1, hop_frames):
            end = start + window_frames
            w = {
                "codes_ch0": torch.tensor(np.array(s["codes_ch0"]).reshape(T, 8)[start:end],  dtype=torch.long),
                "codes_ch1": torch.tensor(np.array(s["codes_ch1"]).reshape(T, 8)[start:end],  dtype=torch.long),
                "vad_ch0":   torch.tensor(np.array(s["vad_ch0"])[start:end],                  dtype=torch.float),
                "vad_ch1":   torch.tensor(np.array(s["vad_ch1"])[start:end],                  dtype=torch.float),
            }
            for name in LABEL_KEYS:
                for ch in ["ch0", "ch1"]:
                    key = f"{name}_{ch}"
                    w[key] = torch.tensor(np.array(s[key])[start:end], dtype=torch.float)
            windows.append(w)
    return {k: torch.stack([w[k] for w in windows]) for k in windows[0]}

ds     = load_dataset("anyreach-ai/dualturn-otospeech-turn-taking")
loader = DataLoader(ds["train"], batch_size=8, shuffle=True,
                    collate_fn=lambda b: collate_windows(b, window_frames=125, hop_frames=25))

batch = next(iter(loader))
print(batch["codes_ch0"].shape)   # [N_windows, 125, 8]
print(batch["eot_ch0"].shape)     # [N_windows, 125]

Label definitions

Label	Meaning
EOT	End-of-Turn: speaker yields the floor
HOLD	Speaker keeps the floor (no handover)
BOT	Beginning-of-Turn: other speaker takes the floor
BC	Backchannel: short acknowledgement, no floor claim
VAD	Voice Activity Detection (1 = speech)

DualTurn Model & Code

The following will be released soon:

• Trained model checkpoint — on HuggingFace at anyreach-ai
• Training code — model architecture, training loop, and configs
• Evaluation code — benchmarks and metrics used in the paper

Authors

• Shangeth Rajaa — Senior ML Research Scientist, Anyreach AI

Citation

This dataset was used for training and evaluation in the DualTurn paper (submitted to Interspeech 2026). splits.json contains the exact train/val/test splits from the official dataset used for all experiments in the paper.

Paper: DualTurn: Learning Turn-Taking from Dual-Channel Generative Speech Pretraining

@misc{rajaa2026dualturnlearningturntakingdualchannel,
      title={DualTurn: Learning Turn-Taking from Dual-Channel Generative Speech Pretraining},
      author={Shangeth Rajaa},
      year={2026},
      eprint={2603.08216},
      archivePrefix={arXiv},
      primaryClass={eess.AS},
      url={https://arxiv.org/abs/2603.08216},
}

If you use this dataset, please cite - otoearth/otoSpeech-full-duplex-280h:

@misc{otoSpeech-full-duplex-280h,
  title        = {otoSpeech-full-duplex-280h: Full-Duplex Conversational Speech Dataset},
  author       = {otoearth},
  year         = {2025},
  howpublished = {\url{https://huggingface.co/datasets/otoearth/otoSpeech-full-duplex-280h}},
  note         = {License: CC BY 4.0}
}