Datasets:

ccde
/

forgetting-regression

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

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)]

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.