radames/flux-klein-tiny-trajectories

FLUX-Klein-Tiny Teacher Trajectories (Stage 1)

59,000 recorded 4-step denoising trajectories from black-forest-labs/FLUX.2-klein-9b-kv, dumped in bf16, eager (uncompiled, unquantized) on an H100, for velocity distillation of smaller students.

Each record stores, for every one of the teacher's 4 sampling steps, the exact triple the student is regressed against: the input latent x_t, the sigma/timestep at that step, and the teacher's predicted velocity v. A student trained on these learns the teacher's vector field rather than its own drift — no teacher forward pass is needed at training time, so distillation runs on a single small GPU.

Companion model repo: radames/flux-klein-tiny.

Why trajectories and not images

Image-level distillation makes the student re-discover the sampler. Here the sampler is given: the schedule is stored per record, and the loss is a plain regression of the student's velocity onto the teacher's at the teacher's own visited points. Because x_t is recorded and not re-derived, the student never trains on states the teacher did not actually pass through, and exposure bias between teacher and student trajectories is removed by construction.

Splits

One config (default), five splits keyed by kind × resolution. Splitting this way rather than using one filterable split is deliberate: sequence length is a function of resolution (256² → 256 latent tokens, 512² → 1024), so each split has a fixed row size. That keeps parquet row groups uniform, lets you stream only the resolution you are training on, and avoids paging 2 MB 512² rows while training at 128². kind and resolution are also present as columns if you prefer to concatenate and filter.

split	rows	resolution	latent tokens (seq_len)	ref tokens	files	size
t2i_128	11,000	128²	64	–	1	1.12 GB
t2i_256	17,500	256²	256	–	5	7.15 GB
t2i_512	25,500	512²	1024	–	29	41.62 GB
edit_256	2,500	256²	256	256	1	1.15 GB
edit_512	2,500	512²	1024	1024	4	4.59 GB
total	59,000				40	55.6 GB

55.6 GB on the hub (zstd); 71.5 GB of raw bf16 payload once decoded.

Schema

column	type	notes
id	string	unique, e.g. t2i_986983b0e505_r256
kind	string	t2i or edit
resolution	int32	128 / 256 / 512 (square, native — never downscaled)
prompt	string	the text the teacher was conditioned on
prompt_id	string	12-hex hash of the prompt; stable across resolutions
seed	int64	the generator seed used for x_0
steps	int32	always 4
seq_len	int32	latent tokens per step (64 / 256 / 1024)
bucket	int32	text-token bucket the prompt was padded into (128 or 256)
sigma	list<float32>	length 4, σ at each step
sigma_next	list<float32>	length 4, σ after each step
timestep	list<float32>	length 4, the scheduler timestep passed to the transformer
xt	binary	raw bf16 bytes, shape xt_shape = [4, seq_len, 128]
xt_shape	list<int32>	[4, seq_len, 128]
v	binary	raw bf16 bytes, shape v_shape = [4, seq_len, 128]
v_shape	list<int32>	[4, seq_len, 128]
ref_latents	binary	edit splits only, else null; packed reference latents
ref_shape	list<int32>	[ref_seq_len, 128], else null
ref_of	string	edit splits only: id of the t2i trajectory the reference came from
tensor_dtype	string	always "bfloat16"

Why bytes

Arrow has no bfloat16 type. Upcasting to fp32 would double the dataset to ~143 GB and would break the bit-exactness guarantee below (bf16 → fp32 → bf16 is lossless, but the stored artifact would no longer be the teacher's output). So the tensors are stored as raw little-endian bf16 bytes plus an explicit shape column, which round-trips byte-for-byte. All shards were written on x86-64 (little-endian).

Loading and decoding

import torch
from datasets import load_dataset

ds = load_dataset("radames/flux-klein-tiny-trajectories", split="t2i_512", streaming=True)
row = next(iter(ds))

def decode(buf, shape):
    # bytearray() makes the buffer writable, which silences torch's non-writable warning
    return torch.frombuffer(bytearray(buf), dtype=torch.bfloat16).reshape(tuple(shape))

xt = decode(row["xt"], row["xt_shape"])   # [4, 1024, 128] bfloat16
v  = decode(row["v"],  row["v_shape"])    # [4, 1024, 128] bfloat16

sigma      = torch.tensor(row["sigma"])       # [4] float32
sigma_next = torch.tensor(row["sigma_next"])  # [4] float32
timestep   = torch.tensor(row["timestep"])    # [4] float32

# edit splits only
ref = decode(row["ref_latents"], row["ref_shape"]) if row["ref_latents"] else None

NumPy, if you would rather not pull in torch (ml_dtypes provides the bf16 view):

import numpy as np, ml_dtypes
xt = np.frombuffer(row["xt"], dtype=ml_dtypes.bfloat16).reshape(row["xt_shape"])

Distillation loss

The trajectory is a plain Euler integration, so the student sees x_t and must predict v:

for step in range(4):
    v_hat = student(xt[step], timestep=timestep[step], encoder_hidden_states=emb)
    loss  = torch.nn.functional.mse_loss(v_hat.float(), v[step].float())

The teacher's own update, for reference, is x_{t+1} = x_t + (sigma_next - sigma) * v.

Verification

Two gates were run over the full dump before it was packaged, and a third after.

1. Euler self-consistency (all 59,000 records). Stored x_t, v, sigma and sigma_next must reproduce the next stored x_t exactly: 59000/59000 within 2 bf16 ULP of the latent scale, worst 0.00781 (bf16 eps = 0.00391). The trajectory is internally consistent — the stored velocity really is the one that produced the stored next state.
2. Bit-exact teacher replay (8 sampled trajectories). The teacher was re-loaded and re-run on stored inputs: 8/8 bit-exact, fresh_rel_l2 = replay_rel_l2 = rerun_rel_l2 = 0.0, replay_cos = 1.0, seed_x0_identical = true. This is only meaningful because the dump was eager and unquantized; a compiled or FP8 teacher is not bit-reproducible across processes.
3. Packaging round-trip (this repo). 255 trajectories stratified across all five splits were decoded back out of the parquet and compared with the source safetensors: 0 failures, both as torch.equal on the decoded tensors and as raw byte equality. All 59,000 ids and every metadata field matched the source index.

Rebuilding the on-disk training format

The training code in radames/flux-klein-tiny reads sharded safetensors + a JSONL index (distill/shards.py), not parquet. To go back to that layout, write each row's xt/v/ref_latents bytes straight into a safetensors data section — no decode, no re-encode, so the shards come back byte-identical:

# per shard: entries = [(f"{id}.xt", "BF16", xt_shape, xt_bytes), ...]
header = {}; off = 0
for name, dtype, shape, raw in entries:
    header[name] = {"dtype": dtype, "shape": list(shape), "data_offsets": [off, off + len(raw)]}
    off += len(raw)
blob = json.dumps(header, separators=(",", ":")).encode()
blob += b" " * ((-len(blob)) % 8)          # safetensors pads the header to 8 bytes
with open(path, "wb") as f:
    f.write(struct.pack("<Q", len(blob))); f.write(blob)
    for *_, raw in entries: f.write(raw)

The index record per trajectory needs id, kind, res, seq_len, steps, prompt_id, ref_seq_len and shard — everything else in the index is provenance.

This path has been exercised. On 2026-08-15 the machine holding the original dump was evicted and its disk was lost. The dataset was rebuilt from this repo into the training layout and re-gated with the project's own Euler self-consistency check, which reported 59000/59000 within 2 bf16 ULP of the latent scale, worst 0.00781 — the same figures the original teacher dump produced. Full-coverage verification (all 300,000 tensors) and stratified bit-comparison both passed. This repo is a sufficient backup of the trajectories: only student_embeds (regenerable, see below) and the teacher's PNG renders do not survive in it.

Provenance

• Teacher: black-forest-labs/FLUX.2-klein-9b-kv (Apache-2.0), bf16, eager, not quantized, not compiled. Capture point is scheduler.step(model_output, timestep, sample), which receives (v, t, x_t) already sliced to the latent tokens, identically for t2i and edit paths.
• Prompts: 54,026 unique. The bulk are captions from jasperai/monet (Apache-2.0), text only — filtered to nsfw < 0.2, watermark < 0.2, 30–600 chars, exact dedup, whitespace-normalized. Complemented by 4,000 synthetic constraint-bearing prompts (hex colours, quoted text, macro/low-light/flat-graphic content types) generated by a seeded combinatorial synthesizer in the project repo. Median t2i prompt length is 447 characters.
• No images from any external dataset are used or redistributed. MONET is read caption-column-only. The 5,000 reference images behind the edit splits were generated by the teacher itself from those prompts, and only their packed latents (ref_latents) ship here — the PNGs do not.
• Edit instructions: 26 distinct instructions (e.g. "Make it night time with warm street lighting, keep the composition unchanged") applied across the 5,000 teacher- generated references, 2,500 at 256² and 2,500 at 512².
• Cost: 59,000 trajectories in 12,125 s wall on one H100; median 0.20 s each.

What is deliberately not here

Student text embeddings are excluded. The dump also produced 7680-wide embeddings from the 4B student's text encoder (54,026 of them, 2.06 MB each, **109 GB**). They are a pure function of the prompt text that is already in this dataset, so shipping them would nearly triple the download for nothing. Regenerate them with:

python -m distill.dump_trajectories --out /path/to/data --student-embeds

(from radames/flux-klein-tiny; loads only the 4B text encoder, no teacher, and dedups by prompt hash across resolutions and t2i/edit reuse). Teacher embeddings are not included either and are not useful to a student: they are 12288-wide against the student's 7680.

Also not included: the teacher's PNG renders (1.2 GB), which are an artifact of the reference pass rather than training data.

Limitations

• Square resolutions only (128², 256², 512²). The sigma schedule is a function of image_seq_len, so a 512² trajectory says nothing about the 256² schedule — do not mix schedules across resolutions.
• Exactly 4 steps per trajectory. This is a distillation set for few-step students, not a general flow-matching corpus.
• Single seed family; x_0 is deterministic given seed, so the dataset does not cover per-prompt noise diversity.
• Prompts are English and inherit MONET's (cc12m-derived) content distribution and its captioner biases.

License

Apache-2.0, matching the teacher and the MONET caption text this was prompted with.

Citation

@misc{flux_klein_tiny_trajectories_2026,
  title  = {FLUX-Klein-Tiny Teacher Trajectories},
  author = {Radamés Ajna},
  year   = {2026},
  url    = {https://huggingface.co/datasets/radames/flux-klein-tiny-trajectories}
}