| --- |
| configs: |
| - config_name: N4_V16 |
| data_files: |
| - split: train |
| path: N4_V16/train-*.parquet |
| - split: validation |
| path: N4_V16/validation-*.parquet |
| - split: test |
| path: N4_V16/test-*.parquet |
|
|
| - config_name: N8_V16 |
| data_files: |
| - split: train |
| path: N8_V16/train-*.parquet |
| - split: validation |
| path: N8_V16/validation-*.parquet |
| - split: test |
| path: N8_V16/test-*.parquet |
|
|
| - config_name: N16_V16 |
| data_files: |
| - split: train |
| path: N16_V16/train-*.parquet |
| - split: validation |
| path: N16_V16/validation-*.parquet |
| - split: test |
| path: N16_V16/test-*.parquet |
|
|
| - config_name: N32_V16 |
| data_files: |
| - split: train |
| path: N32_V16/train-*.parquet |
| - split: validation |
| path: N32_V16/validation-*.parquet |
| - split: test |
| path: N32_V16/test-*.parquet |
|
|
| - config_name: N64_V16 |
| data_files: |
| - split: train |
| path: N64_V16/train-*.parquet |
| - split: validation |
| path: N64_V16/validation-*.parquet |
| - split: test |
| path: N64_V16/test-*.parquet |
|
|
| - config_name: N128_V16 |
| data_files: |
| - split: train |
| path: N128_V16/train-*.parquet |
| - split: validation |
| path: N128_V16/validation-*.parquet |
| - split: test |
| path: N128_V16/test-*.parquet |
|
|
| - config_name: N256_V16 |
| data_files: |
| - split: train |
| path: N256_V16/train-*.parquet |
| - split: validation |
| path: N256_V16/validation-*.parquet |
| - split: test |
| path: N256_V16/test-*.parquet |
|
|
| - config_name: N512_V16 |
| data_files: |
| - split: train |
| path: N512_V16/train-*.parquet |
| - split: validation |
| path: N512_V16/validation-*.parquet |
| - split: test |
| path: N512_V16/test-*.parquet |
|
|
| - config_name: N1024_V16 |
| data_files: |
| - split: train |
| path: N1024_V16/train-*.parquet |
| - split: validation |
| path: N1024_V16/validation-*.parquet |
| - split: test |
| path: N1024_V16/test-*.parquet |
| license: mit |
| task_categories: |
| - other |
| pretty_name: Recognition Memory |
| size_categories: |
| - 1M<n<10M |
| --- |
| |
| # Recognition Memory |
|
|
| A benchmark for memories that *recognise* rather than *recall*: the model sees a sequence |
| and must decide whether it is consistent with what it has stored, for example by using low |
| surprise as the familiarity signal. |
|
|
| ## Subsets |
|
|
| `N4_V16`, `N8_V16`, `N16_V16`, `N32_V16`, `N64_V16`, `N128_V16`, `N256_V16`, `N512_V16`, `N1024_V16`: sequences of length N over a vocabulary of 16 tokens. |
| Splits: train 900,000 / validation 50,000 / test 100,000 samples. |
|
|
| ## Fields |
|
|
| | field | type | description | |
| |---|---|---| |
| | `sequence` | `uint8[N]` | primary sequence, tokens i.i.d. uniform over `0..15` | |
| | `corrupted` | `uint8[8][N]` | 8 corrupted copies of `sequence` | |
| | `num_changed` | `uint16[8]` | number of tokens changed in each corrupted copy | |
|
|
| ## Corruption process |
|
|
| For each corrupted copy, one position chosen uniformly at random is always changed, and each |
| of the other N-1 positions is changed independently with probability 1/(N-1). The number of |
| changed tokens is therefore `1 + Binomial(N-1, 1/(N-1))`, with expectation exactly 2. A changed |
| token is replaced by a uniformly random *different* token, so every corrupted copy differs from |
| the primary sequence. The 8 copies are drawn independently, so two copies of the |
| same sample can coincide (in about 4.4% of samples for N=4, 2.7% for N=8, 1.5% for N=16, and |
| roughly halving with each doubling of N after that). |
|
|
| Primary sequences are drawn i.i.d. and are not deduplicated. For N=4 there are only |
| 16^4 = 65,536 possible sequences, so nearly all of them appear in train and every |
| validation/test sequence also appears in train. From N=16 up, overlap between splits is |
| essentially zero. |
|
|
| ## Evaluation protocol |
|
|
| 1. Give the memory the primary `sequence` (for example, in context before a separator). |
| 2. Score `sequence` and each of its 8 `corrupted` copies with the memory's familiarity signal (for example, |
| minus the summed surprise of the candidate, or a learned score). |
| 3. Report, over the test split: |
| - **acc9**: the share of samples where `sequence` scores strictly highest among the 9 candidates. A tie for the top |
| score counts as 1/(number tied), so a constant score gives 1/9. |
| - **pairwise**: the share of (`sequence`, corrupted copy) pairs where `sequence` scores higher, with ties counting |
| as 1/2. Chance is 0.5. |
| |
| Reference points: a memory that keeps only the sum of the tokens mod 16 (4 bits) gets acc9 about 0.85 at every N, and |
| one that also keeps a position-weighted sum (8 bits) about 0.97, because the corruptions are small edits. |
|
|
| ## Usage |
|
|
| ```python |
| from datasets import load_dataset |
| ds = load_dataset("irodkin/recognition-memory", "N64_V16") |
| ``` |
|
|
| ## Reproduction |
|
|
| Generated with `generate.py` (base seed 20261030); every chunk of 50k samples is seeded from |
| `(seed, N, V, split, chunk)` and can be regenerated on its own. |
|
|
