neurips2026lrtransfer/LR-Transfer-Trajectory

Dataset Documentation

Overview

This dataset captures per-step training and validation metrics from training runs of a 12-layer GPT-style decoder-only transformer. Each run is stored as a single .csv file in which every row corresponds to one logged step, and several columns hold per-parameter measurements encoded as JSON.

The dataset is designed to support post-hoc analysis of:

• Loss curves (train / val)
• Throughput and step latency
• Per-layer / per-parameter dynamics: gradients, optimizer outputs, parameter updates, weights, and the alignment between optimizer outputs and weights

Model Architecture

All runs share the same architectural skeleton, identifiable from the JSON keys (transformer.h.0 … transformer.h.11):

Property	Value
Family	GPT-style decoder-only transformer
Number of layers	12
Per-block parameters	attn.c_q, attn.c_k, attn.c_v, attn.c_proj, mlp.c_fc, mlp.c_proj
Embedding	transformer.wte.weight (token embeddings)
Compilation	torch.compile (keys are prefixed with module._orig_mod.…, indicating DDP + compiled module)

Parameter keys in the JSON columns follow the pattern:

module._orig_mod.transformer.h.{layer_idx}.{submodule}.{param}.weight

with layer_idx ∈ [0, 11] and submodule ∈ {attn, mlp}.

File Layout

The dataset is organized into top-level directories, one per optimizer / schedule combination. Each directory holds a grid of CSV files, one per training run, where the filename encodes the two swept hyperparameters: model width (n_embd) and learning rate (as -log2(lr)).

Directory structure

LRTransferData/
├── adam_ws/        # Adam,  WS  (warmup–stable, no step decay) 
├── adamw_ws/       # AdamW, WS
├── adamw_wsd/      # AdamW, WSD (warmup–stable–decay; decay phase resumes from the corresponding WS run)
├── adamh_ws/       # AdamH, WS
└── adamh_wsd/      # AdamH, WSD

Directory	Optimizer	Schedule
adam_ws	Adam	warmup–stable (no decay)
adamw_ws	AdamW	warmup–stable (no decay)
adamw_wsd	AdamW	warmup–stable–decay
adamh_ws	AdamH	warmup–stable (no decay)
adamh_wsd	AdamH	warmup–stable–decay

File naming

Within each directory, runs are named:

{n_embd}_{neg_log2_lr}.csv

where:

• n_embd — model embedding dimension (integer), which also fixes head count and MLP width via the standard GPT scaling.
• neg_log2_lr — the peak learning rate encoded as -log₂(lr). To recover the learning rate: lr = 2 ** -neg_log2_lr. Larger values of neg_log2_lr mean smaller learning rates.

Examples:

Filename	n_embd	neg_log2_lr	Peak lr
768_8.csv	768	8	2⁻⁸ ≈ 3.91e-3
768_10.csv	768	10	2⁻¹⁰ ≈ 9.77e-4
1024_12.csv	1024	12	2⁻¹² ≈ 2.44e-4

File-level conventions

• One CSV per training run (one (n_embd, lr) cell of the sweep).
• One row per logged step. Logging cadence is run-dependent; the step column is the source of truth.
• UTF-8, comma-separated, with a single header row. JSON columns contain commas, so a CSV reader that handles quoted fields is required (pandas.read_csv works out of the box).

Column Reference

Notation. We write $w_t$ for the parameter tensor at step $t$, $u_t$ for the optimizer's output at step $t$ (the proposed update direction before it is scaled by the learning rate), and $w_{t+1} - w_t$ for the realized parameter update. All norms below are L2 (Frobenius) norms of the corresponding tensor, flattened.

Scalar columns

Column	Type	Description
step	int	Optimizer step index $t$. Monotonically increasing within a run.
phase	str	Phase label for the row. Observed values are train and val; rows tagged val carry validation-time measurements taken at that step.
train_loss	float	Training loss at this step (cross-entropy, in nats).
val_loss	float	Validation loss. Populated on val rows; may be 0.0 / NaN on pure training rows depending on the run.
training_time_ms	float	Cumulative wall-clock training time, in milliseconds, since the start of the run.
step_avg_time_ms	float	Rolling average step time, in milliseconds.

JSON columns

Each of the following columns contains a JSON object serialized as a string. Keys are parameter names (see Model Architecture), values are floats — one number per parameter tensor.

Column	Symbol	Definition
grad_norms_json	$\lVert g_t \rVert_2$	L2 norm of the gradient tensor for the parameter at step $t$.
optimizer_norms_json	$\lVert u_t \rVert_2$	L2 norm of the optimizer output $u_t$ — the update direction returned by the optimizer at step $t$, before the learning-rate scaling.
update_norms_json	$\lVert w_{t+1} - w_t \rVert_2$	L2 norm of the realized parameter update between step $t$ and step $t+1$.
weight_norms_json	$\lVert w_t \rVert_2$	L2 norm of the parameter tensor itself at step $t$.
correlations_json	$\dfrac{\langle u_t,, w_t \rangle}{\lVert u_t \rVert_2^{,2}}$	Inner product between the optimizer output $u_t$ and the current weights $w_t$, normalized by $\lVert u_t \rVert_2^{2}$. Measures how much of $u_t$ is aligned with the existing weight vector (i.e. the coefficient of the projection of $w_t$ onto $u_t$).

Loading and Parsing in Python

import pandas as pd
import json

df = pd.read_csv("run_xxx.csv")

JSON_COLS = [
    "grad_norms_json",
    "optimizer_norms_json",
    "update_norms_json",
    "weight_norms_json",
    "correlations_json",
]

for col in JSON_COLS:
    df[col] = df[col].apply(lambda s: json.loads(s) if isinstance(s, str) else {})