---
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.