Datasets:
File size: 4,808 Bytes
b731359 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | ---
license: cc-by-4.0
task_categories:
- tabular-regression
tags:
- continual-learning
- catastrophic-forgetting
- synthetic
- tabular
- regression
pretty_name: Ten-part regression forgetting benchmark
size_categories:
- 10K<n<100K
configs:
- config_name: seed_0
data_files:
- split: train
path: data/seed_0/train.csv
- split: test
path: data/seed_0/test.csv
- config_name: seed_1
data_files:
- split: train
path: data/seed_1/train.csv
- split: test
path: data/seed_1/test.csv
- config_name: seed_2
data_files:
- split: train
path: data/seed_2/train.csv
- split: test
path: data/seed_2/test.csv
- config_name: seed_3
data_files:
- split: train
path: data/seed_3/train.csv
- split: test
path: data/seed_3/test.csv
- config_name: seed_4
data_files:
- split: train
path: data/seed_4/train.csv
- split: test
path: data/seed_4/test.csv
---
# Ten-part regression forgetting benchmark
A synthetic multi-variable regression stream for measuring **catastrophic
forgetting**. One shared nonlinear target `f: R^6 -> R`; ten input
distributions with disjoint support; one scalar output. A model is trained on
part 0, then part 1, …, evaluated on every part after every stage. Task identity
is never given, so this is a *domain-incremental* regression benchmark.
It is the data behind the forgetting experiments in
`neural_memory/FORGETTING.md`: a plain MLP fits each part to R² ≈ 0.85–0.93 and
then loses it all (mean backward transfer −2.1), replay of 32 points per part
removes the forgetting (−0.03), and EWC/SI barely help.
## Structure
| config | splits | rows |
|---|---|---|
| `seed_0` … `seed_4` | `train` (5,120), `test` (2,560) | 7,680 per config |
Each config is an independent draw of the whole stream (same generator, different
seed). Rows are grouped by `task_id` in training order and keep the generator's
row order inside a part. Files are CSV; the Hub converts them to Parquet for its
viewer, and numeric columns load as `float64` holding the original float32
values.
| column | type | meaning |
|---|---|---|
| `task_id` | int | part index, 0–9 (training order) |
| `x0` … `x5` | float | input variables |
| `y` | float | target; noisy on `train`, clean on `test` |
| `y_clean` | float | the noiseless target `f(x)` |
Training targets carry noise with standard deviation `0.1 · std(f)` on that
part; test targets are noiseless, so a score measures the learned function
rather than a noise draw.
## Loading
```python
from datasets import load_dataset
train = load_dataset("ccde/forgetting-regression", "seed_0", split="train")
part3 = train.filter(lambda row: row["task_id"] == 3)
# or the whole stream, part by part, in benchmark order
stream = [train.filter(lambda row, k=k: row["task_id"] == k) for k in range(10)]
```
```python
import pandas as pd
frame = pd.read_csv("hf://datasets/ccde/forgetting-regression/data/seed_0/train.csv")
```
## Generation
Part `t` draws `x = c_t + s · z_t · L_t^T` and `y = f(x) + ε`, with
- `c_t`: part mean on the sphere of radius 3 in R^6, placed by greedy
farthest-point sampling (minimum pairwise distance 3.80 for seed 0);
- `L_t`: random rotation × log-spaced axes spanning a factor of 2 (geometric
mean 1), so each part is a differently oriented ellipsoid;
- `z_t`: unit-covariance sample whose marginal cycles Gaussian → uniform →
Laplace from part to part;
- `s = 0.35`: within-part scale; parts are disjoint (a nearest-centre classifier
recovers the part with accuracy ≥ 0.99);
- `ε`: training-only noise, `0.1 · std(f)`.
The shared target is
```
f(x) = sin(1.5 x1) cos(1.5 x2) + 0.6 tanh(x3 x4) + 0.3 ((mean_i x_i^2) - 9)/4
```
## Evaluation protocol
Score each part by `R² = 1 − MSE / Var(y_clean)`, giving a 10 × 10 matrix
`a[t][j]`: R² on part `j` after training part `t`. Report `ACC` (mean of the
final row), `BWT` (mean over `j < 9` of `a[9][j] − a[j][j]`; negative means
forgetting), `LA` (mean diagonal) and `FWT`. Per-part normalisation matters:
part target standard deviations range from 0.35 to 0.60.
## Limitations
- Synthetic and deliberately disjoint: it stresses retention, not
generalisation within a part.
- One target family, six inputs, ten parts. Vary `f` for a harder stream; the
generator supports per-part rotations of `f`.
- No task identifiers, no validation split, no real-world data.
- The five configs are independent streams, not five views of one stream.
## Provenance
Generated by `modules/forgetting_data.py` (seed = config suffix) from the
`neural_memory` repository; `benchmarks/export_forgetting.py` rebuilds these
files. Version 1.0.
|