Thousand Brains v5 · Compression

each codec is text or image · score = acc × ratio × timePenalty (text ratio⁵ · image acc³⁰·∛ratio · slow encode/decode penalised) · loading…
0 training 0 eval · 0 models
archive: v4 v3

Family share vs 40/30/30 target

the selector routes the next exploration run to the largest deficit.

Modality coverage

specialists allowed; finalScore averages only implemented modalities.

Learning rules backprop ≤ 50%

room for predictive-coding / Hebbian-with-coding / ES / forward-forward.

Live ops

GPUs, in-flight runs, next-cycle briefings

Live GPUs

no GPU data

Next-cycle briefings

Forbidden patterns

    Leaderboard

    modality: family: · text & image score on different scales, so they're shown separately · family narrows within the modality · ◓ = tunable (champion-eligible) · baselines shaded · rows below the modality baseline dimmed · click a row for detail

    Frontiers

    the headline view per modality. ✦ baselines · dashed = Pareto frontier · up-and-right wins

    ● Image — rate vs distortion

    x = compressionRatio (log), y = accuracy. bubble size = decode speed (deflateRatio).

    ● Text — rate vs decode-speed

    lossless ⇒ accuracy is always 1.0, so the real tradeoff is size vs speed: x = compressionRatio (log), y = deflateRatio (log).

    Score breakdown

    where models land and what drives each score

    finalScore distribution

    non-baseline models, log-binned; baseline bar marked.

    Score factor mix — top models

    accuracy × compressionRatio × timePenalty (log) — text ratio⁵, image acc³⁰×∛ratio (×100); timePenalty = 0.99^(decode/u)·0.99^(encode/1s) shaves slow decode/encode.

    Tradeoffs

    the cost dimensions: encode effort and decode speed

    Compress vs decode time

    x = compress ms (log), y = decode ms (log). per-item codecs pay a big compress cost (training folds in) — only decode is scored.

    Decode speed vs baseline (deflateRatio)

    1.0 = baseline decode speed. >1 faster (scores up), <1 slower (scores down). top models by finalScore.

    Efficiency

    score per unit of decode latency, encode effort, and model size (measured, NOT scored)

    finalScore vs decode latency

    x = total decode ms (log), y = finalScore (log). up-and-left = high score, fast decode.

    finalScore vs encode cost

    x = total compress ms (log, incl. per-item training), y = finalScore (log). the real-world write cost.

    finalScore vs model size

    x = parameters (log), y = finalScore (log). bubble = train seconds. classical/0-param codecs are omitted.

    Per-file deep dive

    how each model handles each individual corpus file

    Model × file heatmap

    rows = models (by finalScore), cols = test files.

    Compressed size per model

    payload bytes for the selected file (log). shorter = better; raw size noted on the axis.
    file

    Model profiles

    the shape of each codec, and where models cluster

    Radar — top models

    accuracy · ratio · decode-speed · compress-speed · param-thrift, each min–max normalised across shown models.

    Accuracy vs ratio — both modalities

    x = compressionRatio (log), y = accuracy. shape = modality.

    Correlation lab

    slice the data on any two axes, or compare every metric at once

    XY explorer

    pick any two metrics; color = family, ✦ baselines.
    x y

    Parallel coordinates

    each line is a model across all metrics (min–max normalised). color = family.

    Families & labels

    which families and design patterns actually win

    Family distribution & mean score

    bars = mean finalScore (log), line = model count.

    Label lift on finalScore

    top-tertile rate − bottom-tertile rate per archLabel (needs ≥3 evaluated models).

    Champion lineage

    single-knob ablation chains and how each knob moved finalScore

    Training dynamics

    per-architecture training curves (loss / fitness / bits-per-byte)
    model metric