README.md

---
license: cc-by-nc-4.0
language:
  - en
task_categories:
  - question-answering
  - audio-text-to-text
pretty_name: VoxMem
tags:
  - benchmark
  - memory
  - long-context
  - spoken-dialogue
  - conversational-memory
  - paralinguistics
  - speaker-recognition
  - environmental-sound
size_categories:
  - 1K<n<10K
configs:
  - config_name: 8k
    data_files: data/8k/*/*.parquet
  - config_name: 16k
    data_files: data/16k/*/*.parquet
  - config_name: 32k
    data_files: data/32k/*/*.parquet
    default: true
  - config_name: 64k
    data_files: data/64k/*/*.parquet
  - config_name: 8k_speech_semantics
    data_files: data/8k/speech_semantics/*.parquet
  - config_name: 8k_speaker_information
    data_files: data/8k/speaker_information/*.parquet
  - config_name: 8k_paralinguistic_information
    data_files: data/8k/paralinguistic_information/*.parquet
  - config_name: 8k_environmental_sound
    data_files: data/8k/environmental_sound/*.parquet
  - config_name: 16k_speech_semantics
    data_files: data/16k/speech_semantics/*.parquet
  - config_name: 16k_speaker_information
    data_files: data/16k/speaker_information/*.parquet
  - config_name: 16k_paralinguistic_information
    data_files: data/16k/paralinguistic_information/*.parquet
  - config_name: 16k_environmental_sound
    data_files: data/16k/environmental_sound/*.parquet
  - config_name: 32k_speech_semantics
    data_files: data/32k/speech_semantics/*.parquet
  - config_name: 32k_speaker_information
    data_files: data/32k/speaker_information/*.parquet
  - config_name: 32k_paralinguistic_information
    data_files: data/32k/paralinguistic_information/*.parquet
  - config_name: 32k_environmental_sound
    data_files: data/32k/environmental_sound/*.parquet
  - config_name: 64k_speech_semantics
    data_files: data/64k/speech_semantics/*.parquet
  - config_name: 64k_speaker_information
    data_files: data/64k/speaker_information/*.parquet
  - config_name: 64k_paralinguistic_information
    data_files: data/64k/paralinguistic_information/*.parquet
  - config_name: 64k_environmental_sound
    data_files: data/64k/environmental_sound/*.parquet
---

# VoxMem: Long-Term Spoken Conversational Memory

VoxMem evaluates whether a spoken-dialogue system remembers what it heard.
A model is given many time-separated sessions of a conversation — every user
turn as audio, every assistant turn as text — and is then asked a spoken
question whose answer is somewhere in that history.

**799 questions × 4 context lengths = 3,196 items.**

What separates this from a text memory benchmark is *where the answer lives*.
Three of the four evidence types are carried by the audio signal, not by the
words, so a system that transcribes first and remembers later cannot reach them.

| Evidence type | The answer depends on | Items |
|---|---|---|
| `speech_semantics` | what the user said | 928 |
| `speaker_information` | who was speaking | 588 |
| `paralinguistic_information` | how it was said — vocal delivery | 1,056 |
| `environmental_sound` | what could be heard around the user | 624 |

## Task

```
Session timestamp: 2025-06-17 09:27
  user       <audio>
  assistant  text
  ...
Session timestamp: 2025-06-23 01:52
  user       <audio>
  ...
Session timestamp: 2025-09-01 07:44
  user       <audio>      <- the question
```

Sessions are days or weeks apart. The model answers from the history it was
given; it is never given a transcript.

## Memory operations

| Operation | The item asks the model to | Items |
|---|---|---|
| `information_extraction` | recover one fact from one session | 920 |
| `multi_session_reasoning` | combine evidence across sessions | 884 |
| `temporal_evolution_tracking` | track how something changed over time | 872 |
| `answer_refusal` | recognise that the history does not contain the answer | 520 |

Evidence type × memory operation gives **15 occupied cells**.
`speech_semantics × information_extraction` is deliberately empty: reading one
fact out of one transcript is not what this benchmark is for.

## Context lengths

Every question appears at four history lengths — 8K, 16K, 32K and 64K audio
tokens — under one `question_id`. The question, the gold answer and the
evidence are identical across the four; only the surrounding history grows, and
it grows by nesting:

```
sessions(8K) ⊆ sessions(16K) ⊆ sessions(32K) ⊆ sessions(64K)
```

so a length comparison holds the item fixed and varies only the distraction.
Four `latest_state` questions do not nest strictly — `q_00154`, `q_00158`,
`q_00365`, `q_00645` — drop them from a strict length sweep.

## What you download

Every row carries its own history and every clip in it, so no config depends on
any other. Sessions are shared between questions in the source data, but they
are materialised into each item, which is what lets you take a slice and run it.

The files are laid out by context length and then by evidence type:

```
data/<context length>/<evidence type>/train-000NN-of-000NN.parquet
```

and there is a config for each level, so you can take a whole context length,
or a single evidence type within it:

| Config | Items | 8K | 16K | 32K | 64K |
|---|---|---|---|---|---|
| `<length>` (all evidence) | 799 | 4.03 GB | 7.72 GB | 15.38 GB | 32.83 GB |
| `<length>_speech_semantics` | 232 | 1.19 GB | 2.26 GB | 4.50 GB | 9.18 GB |
| `<length>_speaker_information` | 147 | 0.73 GB | 1.41 GB | 2.80 GB | 6.52 GB |
| `<length>_paralinguistic_information` | 264 | 1.33 GB | 2.55 GB | 5.12 GB | 10.38 GB |
| `<length>_environmental_sound` | 156 | 0.79 GB | 1.50 GB | 2.96 GB | 6.75 GB |

```python
load_dataset("AudioMemory/voxmembench", "32k")                             # 799 items
load_dataset("AudioMemory/voxmembench", "32k_paralinguistic_information")  # 264 items
```

Testing whether your system hears vocal delivery at 32K costs
5.12 GB, not the whole benchmark.

## History composition

Every session in an item's history is labelled with its role:

| Role | What it is |
|---|---|
| `evidence` | the session the answer comes from |
| `samekey_haystack` | shares the question's retrieval key, and is ruled out only by the selector the question states |
| `topical_haystack` | shares the topic but not the queried attribute |
| `filler` | unrelated conversation |

`samekey_haystack` is what stops length from being free. Without it, retrieval
succeeds on topic words alone; with it, the model has to apply the selector the
question actually states. It scales 1 / 2 / 4 / 8 with the context length. The
16 answerable questions that carry none at any length — the question names only
the topic, so nothing can be ruled out — are usable as a control group; filter
on `samekey_haystack_session_count`. Refusal items carry no haystack by design.

## Loading

```python
from datasets import load_dataset

ds = load_dataset("AudioMemory/voxmembench", "32k", split="train")

item = ds[0]
print(item["question_text"], item["gold_json"])

# the spoken question
question = item["question_audio"]        # {"array": ..., "sampling_rate": 24000}

# the history, in order, with every user clip already decoded
for session in item["sessions"]:
    print(session["timestamp"], session["role"])
    for turn in session["turns"]:
        if turn["audio"]:
            audio = turn["audio"]["array"]
        else:
            assistant_text = turn["text"]
```

Audio arrives decoded because the shards declare their Hugging Face feature
types; `datasets` needs its audio extra (`pip install "datasets[audio]"`). To
avoid that dependency, read the parquet directly and decode the bytes yourself:

```python
import pyarrow.parquet as pq, soundfile as sf, io

path = "data/32k/paralinguistic_information/train-00000-of-00005.parquet"
row = pq.read_table(path).slice(0, 1).to_pylist()[0]
wav, sr = sf.read(io.BytesIO(row["question_audio"]["bytes"]))
```

Streaming works too (`streaming=True`); row groups are about 128 MB, so a
reader fetches one group rather than a whole shard to see a row.

## Item schema

One row per `(question_id, context_length)`, self-contained.

| Field | Type | Description |
|---|---|---|
| `item_id` | string | `<question_id>_<context length>`, unique in the release |
| `question_id` | string | stable across the four context lengths, e.g. `q_00142` |
| `context_length` | string | `8K`, `16K`, `32K`, `64K` |
| `family_id` | string | question family; one family may hold both an answerable and a refusal question |
| `evidence_type` | string | one of the four above |
| `memory_operation` | string | one of the four above |
| `subtype` | string | finer question type, e.g. `cue_to_fact`, `latest_state`, `counting` |
| `question_text` | string | transcript of the spoken question, for reference |
| `question_audio` | audio | the spoken question |
| `query_timestamp` | string | when the question is asked |
| `gold_json` | string | the gold answer, JSON-encoded |
| `answer_type` | string | `categorical`, `short_text`, `ordered_list`, `yes_no`, `number`, or null for refusal items |
| `answer_normalization` | string | how to compare an answer to the gold |
| `expected_response` | string | `answer`, or `insufficient_evidence` for refusal items |
| `sessions` | list[session] | the history, in order |
| `evidence_session_ids` | list[string] | the sessions holding the evidence |
| `evidence_session_indices` | list[int] | their positions in `sessions` |
| `evidence_relative_positions` | list[float] | the same positions as 0.0–1.0 |
| `session_count`, `evidence_session_count`, `filler_session_count`, `samekey_haystack_session_count`, `topical_haystack_session_count` | int | history composition |
| `history_audio_tokens`, `history_duration_seconds` | number | size of the history |
| `paired_question_id` | string | the refusal counterpart of an answerable question, where one exists |

A **session** has `session_id`, `timestamp`, `role` and `turns`. A **turn** has
`role` (`user` or `assistant`), `text` and, on user turns, `audio`. All audio is
24 kHz mono.

A user turn carries **both** its audio and the transcript of it, so the
benchmark can be read as well as heard — a text-only run is the ceiling the
audio numbers are measured against. The transcript is the words only: the cue
markers that drove the delivery are not in it, which is what keeps the
paralinguistic, speaker and environmental items out of reach of a reader.

`session_id` is stable across the whole release, so a session reused by two
questions carries the same id in both — useful for caching an encoder's output,
and for checking what a system has already seen.

## Evaluation

Give the model the system prompt, the ordered history as audio plus assistant
text, and the final spoken question. Do not give it a transcript.

```
evaluation/candidate_system_prompt.txt             permits abstention
evaluation/candidate_system_prompt.no_abstain.txt  always answer
evaluation/answerable_judge_prompt.txt             grades answerable items
evaluation/ar_judge_prompt.txt                     grades refusal items
```

**Metric.** Accuracy, reported separately for two strata:

- *answerable* (2,676 items) — correct when the response is semantically
  equivalent to `gold_json` under the item's `answer_normalization`. Answers are
  open-ended, so equivalence is settled by an LLM judge that sees only the
  question, the gold and the response — never the audio or the history.
  `evaluation/answerable_judge_prompt.txt` is that contract. Abstaining is
  incorrect.
- *answer refusal* (520 items) — correct when the response says the evidence is
  insufficient. Score this stratum only under the abstention-permitting prompt;
  under the always-answer prompt it reads ~0 by construction.

Report per context length, and per evidence type × memory operation when
comparing systems: the aggregate hides that the audio-only cells behave nothing
like the semantic ones.

## How the data was made

- **User speech** — voice cloned from 30 reference speakers of the
  [CSTR VCTK Corpus](https://doi.org/10.7488/ds/2645) 0.92. The persona profiles
  in `metadata/speakers.json` are fictional and are not recoverable from the
  voice.
- **Assistant turns** — text, never spoken.
- **Environmental sound** — clips from
  [ESC-50](https://doi.org/10.7910/DVN/YDEPUT), mixed into the user speech at a
  target SNR rather than appended, so the sound is present *while* the user
  talks.
- **Paralinguistic cues** — rendered as vocal delivery in the cloned speech.

## Public annotations

Gold answers, evidence-session annotations and evidence positions are all
public. There is no hidden split and no submission server: the benchmark is
meant to be run locally and analysed — evidence-oracle conditions, retrieval
error analysis, degradation against evidence position, modality ablations —
which all need those fields.

## Licence

CC BY-NC 4.0. The non-commercial term follows from ESC-50, whose clips supply
the environmental sound. Attribution is required for VCTK and for ESC-50; see
`LICENSE`, and `metadata/environmental_sources.json` for the licence of every
clip used.

## Citation

```bibtex
@misc{voxmem2026,
  title  = {VoxMem: Benchmarking Multimodal Memory in Large Audio Language Models},
  author = {The VoxMem authors},
  year   = {2026},
  url    = {https://huggingface.co/datasets/AudioMemory/voxmembench}
}
```