benpeloquin7's picture
Public copies of the tooltalk-samples documents
013e76f verified
|
Raw History Blame Contribute Delete
16.4 kB

ToolTalk Samples: Technical Reference

The reference behind the data page: what ships in each set, how it was recorded and processed, the schema, and how to load it. Use is governed by the Terms on the data page (TERMS.md).

Deliverables and file naming

Every call ships as separate files on one time axis: the studio tracks (forms 1 to 3) and a combined stereo file (form 4). All files of a take have the same length and start on the same instant as the tool-call clock. The Noisy set has all four forms. The Clean set has no noise bed, so it has forms 1, 2 and 4, and its combined file is the two clean tracks side by side.

Form File What it is In Processing Format
1. Clean agent <take_id>_agent.wav (agent_file) The agent's microphone All sets None 48 kHz / 32-bit mono WAV
2. Clean customer <take_id>_customer.wav (customer_file) The customer's microphone All sets None 48 kHz / 32-bit mono WAV
3. Ambient noise <take_id>_noise.wav (noise_file) The car-interior bed played into headphones Noisy only None. In 4 of 12 takes the bed touches full scale at its loudest moments (passing vehicles), in runs of at most 1.6 ms and for at most 0.13 s per take 48 kHz / 32-bit mono WAV
4. Combined call <take_id>_stereo.wav (file_name, the audio column) The whole call in one stereo file: customer LEFT, agent RIGHT All sets Noisy only: customer channel through a simulated car cabin, mixed with the ambient bed at a signal-to-noise ratio of +5 dB(A), the customer's speech 5 dB louder than the bed, measured while the customer is talking; agent channel clean; both channels normalized to -27 LUFS under a -1 dBTP ceiling (stereo_content: renoised). Clean only: the two clean tracks side by side, unprocessed (stereo_content: clean) 48 kHz / 32-bit stereo WAV (Clean); 48 kHz / 24-bit stereo WAV (Noisy)
5. Transcripts transcripts/<take_id>_{agent,customer}.json (agent_transcript_file, customer_transcript_file) and <take_id>_transcript.txt Each speaker's track transcribed on its own, plus both merged in time order All sets Machine speech recognition (nvidia/parakeet-tdt-0.6b-v3); not human-reviewed JSON (segments with start/end and word timings) and plain text

Recording specifications

All recordings are in-person in-studio. Mono files are 48 kHz, 32-bit PCM WAV, speaker-separated, recorded on 20 Hz–20 kHz flat-response large-diaphragm condenser microphones into high-quality preamps and converters. The recording environment and signal chain have a sub -60 dB noise floor and RT60 < 90 ms. The 48 kHz / 32-bit recordings are produced without any compression or EQ.

This is fully raw audio, which gives you the most flexibility to preprocess for your own pipeline. We can also provide training-ready audio: normalized, equalized and denoised for high-fidelity speech generation.

Noise collection and post-processing

During the calls in the Noisy set a recorded car-interior noise bed (city street or freeway) was played into both talents' headphones, so they spoke, listened and worked the tools against that noise. The microphones stayed clean: the speech files carry no noise. <take_id>_noise.wav is the bed itself, cut to the exact window of the call and sample-aligned with the speech files, so mixing it under either speaker reproduces what that person heard. Its level is the studio playback file's level. The combined stereo's customer channel was mixed with this same bed span, at its own gain. The Clean set was recorded with no bed playing.

The combined stereo file

In the Noisy set, every take's combined file is a simulation of the call as the agent's side would have received it with the customer calling from a car: the customer channel (LEFT) is the customer's clean recording passed through a simulated car-cabin room and mixed with the very noise bed that was playing in the studio at that moment, with the bed's gain set for a signal-to-noise ratio of +5 dB (A-weighted, measured while the customer is talking), so the customer's speech is 5 dB louder than the bed; the agent channel (RIGHT) is the agent's clean recording. Both channels are loudness-normalized independently to -27 LUFS (ITU-R BS.1770-4) under a -1 dBTP true-peak ceiling, and the file is 24-bit. Speech is high-passed at 20 Hz and the bed at 80 Hz before mixing; there is no compression or limiting. The per-take numbers (target and measured SNR, room RT60, gains) are in the renoised column and in stereo.renoised of the manifest. The mono files are untouched. In the Clean set the combined file is the two clean tracks side by side, customer LEFT, agent RIGHT, unprocessed (stereo_content: clean).

Transcripts

Each speaker's microphone track was transcribed on its own with nvidia/parakeet-tdt-0.6b-v3. Tracks were transcribed in voice-activity chunks of up to 20 seconds, which recovers speech that a single pass over a whole track drops. These are model-generated transcripts, not human-reviewed: expect recognition errors on names, numbers, spellings and overlapping speech, and no punctuation or casing guarantees. Per take: transcripts/<take_id>_agent.json and _customer.json (segments with start/end in seconds from the start of every wav, word timings, the model and run time) and <take_id>_transcript.txt, both speakers merged in time order (one header line naming the model and the time format, a blank line, then one line per segment); the transcript column carries the merged lines without the header.

Episode design and outcomes

Two humans improvise a customer-service call. The caller is given a persona and an objective; the agent talks with the caller while operating the environment's tools. Nothing is scripted line by line.

Each domain has a live database, functions that read and write it, and a written domain policy. State is dynamic (a booking made mid-call changes later searches), and the final database state is a checkable outcome.

Every call is captured as three synchronized tracks: speaker-separated audio (caller and agent on their own channels, overlaps preserved); the function-call log (tool, arguments, result, timing against the audio); and the agent's digital behavior (clicks, typing, record selections, on the same clock).

The collection spans eight domains: ✈️ airline reservations, ❤️‍🩹 healthcare appointment booking, 🏨 hotel booking, 🪑 restaurant reservations, 🍝 restaurant take-out and pick-up, 🚗 roadside assistance, 🛵 food delivery and 🏦 banking. These samples cover seven of them; there is no banking call in this release yet.

Domains in this sample release:

Domain domain Clean Noisy
✈️ Airline reservations airline 2 2
🛵 Food delivery food_delivery 2 0
❤️‍🩹 Healthcare appointment booking healthcare_appts 2 2
🏨 Hotel booking hotel 2 2
🪑 Restaurant reservations restaurant 2 2
🚗 Roadside assistance roadside_assistance 2 2
🍝 Restaurant take-out and pick-up takeout 2 2

Episodes are written in three validity classes against the domain policy: valid (the caller's objective is consistent with policy and the agent fulfills it), partially valid (part is allowed, part is not; the agent fulfills some and holds the line on the rest) and invalid (the objective is at odds with policy; the correct outcome is a refusal or an alternative while the caller pushes back).

Every episode has a reference solution and ideal tool-call sequence (although successful calls may deviate from the ideal sequence).

Dataset schema and organization

Each set is one config: load_dataset("fluid-concepts/tooltalk-samples", "<set>") (sets: clean, noisy) returns one row per call with the columns below; the wav files and transcripts named in the path columns sit beside the metadata under sets/<set>/data/. All wavs of a take are the same length and start at the same instant as the tool-call clock.

Column Type What it is
file_name audio The combined stereo wav of the call (customer LEFT, agent RIGHT). The viewers play the separate tracks (forms 1 to 3); where this file is renoised, the set's viewer also offers it as the example combined output
take_id string Unique id of the take: TLT<yymmdd>_<studio session>__<domain>_<episode>_<scenario>__ep_<ms>_<suffix>; the prefix of every file of the take
short_id string Short form of the take id: studio session code and take token (SC023-6xe1a6)
sample_set string The set this call belongs to (one card config per set)
domain string Customer-service domain key (airline, hotel, restaurant, takeout, healthcare_appts, roadside_assistance, food_delivery); the Domains table above gives the names
episode_number string Three-digit episode index within the domain
scenario string Short name of the episode's situation
description string Hand-written one-paragraph summary of what happens in the call
duration_s float Length of the call in seconds; every wav of the take has exactly this length
n_tool_calls int Number of tool calls the agent made
session string Studio session the take was recorded in
agent_id, customer_id string Anonymous studio codes of the two people, <studio letters>-<number> (FC-012, FR-033, ...)
stereo_content string renoised (customer channel through the car-cabin simulation with the noise bed, agent clean) or clean (the two mono tracks side by side)
agent_file, customer_file string Paths of the two raw mono wavs, relative to sets/<set>/data/
noise_file string Path of the noise-bed wav the talents heard, relative to sets/<set>/data/; null if no bed was playing
agent_transcript_file, customer_transcript_file string Paths of the per-speaker machine transcripts (JSON: segments with start/end in seconds and word timings), relative to sets/<set>/data/
transcript_file string Path of the merged, time-ordered, speaker-labeled transcript (plain text: one header line naming the model and the time format, a blank line, then one line per segment), relative to sets/<set>/data/
transcript_model string The speech-recognition model that produced the transcripts; they are machine-generated and not human-reviewed
noise_bed string Which bed was playing (STREET, FREEWAY); null in sets without a bed
noise_dbfs, noise_dbfs_a float Level of the Ambient file over the whole call: broadband RMS in dBFS, and the same after IEC 61672 A-weighting (what a sound-level meter reads; it discounts the low-frequency rumble these beds are mostly made of); null in sets without a bed
noise_lufs float Integrated loudness of the Ambient file (ITU-R BS.1770-4, gated), the scale the combined file is normalized on; null in sets without a bed
noise_peak_dbfs float Loudest sample of the Ambient file in dBFS; 0.0 means the bed touches full scale at some point; null in sets without a bed
noise_active_fraction float Share of the call during which the bed was playing: the fraction of 20 ms frames of the Ambient file above -60 dBFS; null in sets without a bed
agent_prompt, customer_prompt string The full text each side was given before the call
transcript string The merged machine transcript as text: one line per segment, m:ss.mmm Speaker: words; the lines of the text file without its header
tool_events string (JSON) List of {call_seq, tool_name, tool_input, tool_result, onset_time, land_time, is_error}; times are seconds from the start of every wav
renoised string (JSON) The render record of a renoised combined file: room simulation, high-pass filters, noise mix with the SNR target and measurement, per-channel loudness before and after normalization, output format; null for clean stereo

sets/<set>/manifest.json holds the same information in nested form, keyed by take id: the two participants, one block per audio stream with its format, the noise-bed details, and the tool events. sets/<set>/descriptions.csv is the hand-written description column (take_id,description), and sets.json at the root indexes the sets for the viewer. sets/<set>/derived/ (waveform peaks and MP3 proxies) serves the viewer and is not part of the dataset config.

Synchronizing tool calls with audio

All wavs of a take start at the same instant as the tool-call clock, so a tool call's position in the audio is its onset_time in seconds from the beginning of any of the take's files: seek to onset_time to hear what was being said as the agent submitted the call, and to land_time to hear the moment the result came back. For example, to cut the ten seconds around the first tool call of a take: ffmpeg -ss <onset_time - 5> -t 10 -i <take_id>_stereo.wav clip.wav.

Participant ids (FC-012, FR-033, ...) are anonymous studio codes, written <studio letters>-<number>.

Loading and downloading

Access is per Hugging Face user and covers every set: request it with the form at the top of the data page and we will approve it. Once granted you can play and download every file from the Files tab, and from Python (sign in first with hf auth login, or set HF_TOKEN):

import json
from datasets import Audio, load_dataset

REPO = "fluid-concepts/tooltalk-samples"
ds = load_dataset(REPO, "clean")          # one config per set: "clean", "noisy"; `audio` is the combined stereo
row = ds["train"][0]
samples = row["audio"].get_all_samples()  # torchcodec AudioDecoder: .data is a (channels, samples) tensor, .sample_rate its rate
row["short_id"], row["description"], tuple(samples.data.shape), json.loads(row["tool_events"])[:2]

# The file paths instead of decoded audio
files = ds["train"].cast_column("audio", Audio(decode=False))
files[0]["audio"]["path"]

The plain load_dataset call downloads every wav and transcript of the set before it returns (Clean 2.0 GB, Noisy 1.8 GB); casting Audio(decode=False) afterwards does not avoid that. To look around without the download, read the metadata with the second snippet and fetch single files with hf_hub_download.

Decoding needs pip install "datasets[audio]" (torch and torchcodec; the same packages decode video) and FFmpeg 4 to 7 installed on the system. Without FFmpeg the first decode fails with a torchcodec loader error. Reading the paths needs neither.

row["audio"]["array"], the older dict form, still works but averages the two channels into one mono signal, which throws away the customer/agent separation these files exist for; keep the channels with get_all_samples().data (row 0 the customer, row 1 the agent).

import pandas as pd
from huggingface_hub import hf_hub_download, snapshot_download

# The manifest of one set, without the audio; dtype=False keeps ids such as "031" as strings
meta = pd.read_json(hf_hub_download(REPO, "sets/noisy/data/metadata.jsonl", repo_type="dataset"), lines=True, dtype=False)
meta[["short_id", "domain", "scenario", "duration_s", "n_tool_calls", "noise_bed"]]

# One whole set ...
snapshot_download(REPO, repo_type="dataset", allow_patterns=["sets/noisy/**"])
# ... one stream across every set ...
snapshot_download(REPO, repo_type="dataset", allow_patterns=["sets/*/data/audio/*_agent.wav"])
# ... or everything
snapshot_download(REPO, repo_type="dataset")

From the command line: hf auth login, then hf download fluid-concepts/tooltalk-samples --repo-type dataset --include "sets/noisy/**" --local-dir tooltalk-samples.

The raw mono and noise wavs are the agent_file, customer_file and noise_file columns, relative to the set's data/ folder. Questions: hello@fluidconcepts.ai.