Cadence: Error-Bounded Lossy Compression of Demand Time Series with a Time-Series Foundation Model
Roberto Tacconelli
cs.IT, cs.DB, cs.LG
2026-09-05
TimesFM-3 buys almost nothing for lossless time-series compression (+0.03% median) but cuts error-bounded lossy coding size by 21.4% on grid-demand and subway-ridership data.
Time-series foundation models like TimesFM forecast unseen series zero-shot, and if compression is prediction, a better forecaster should compress better. This paper tests that assumption directly and finds it's mostly false for lossless coding and true only in a narrow domain for lossy coding. The negative result isn't an engineering failure; it follows from a simple identity about how entropy coding works.
Code length under a well-matched residual model is roughly log2(residual scale) plus a constant, so bits saved scale with the log of the accuracy ratio between two predictors, not linearly: Δbits = log2(MAEold/MAEnew). That means halving a 20-bit-per-value file needs a roughly 1000x better forecaster. Building on this, the authors design Cadence, an error-bounded lossy codec that guarantees every reconstructed sample stays within a tolerance τ of the original. Its core trick is closed-loop quantization: the predictor only ever sees its own previously reconstructed values, never the true ones, so the decoder can reproduce the exact same prediction the encoder made. They also build an adaptive arithmetic coder with context-modeled binarization and insist on routing every predictor, neural or classical, through the identical entropy coder before comparing them; skipping this step with a general-purpose backend like xz or zstd manufactured a fake "gains shrink as tolerance widens" trend that reversed once they used a real arithmetic coder.
On lossless coding, TimesFM-3's median gain over the best of six classical predictors across 12 real series is +0.03%, essentially nothing. On Wikipedia pageview data specifically, TimesFM-3 achieves MAE = 113,608 against 171,507 for a 32-tap linear predictor, a genuine 1.51x accuracy improvement, but that converts to just 0.6 bits saved out of a 20.28-bit budget (2.9%). The i.i.d.-noise row validates the whole measurement setup: true entropy is exactly 12.000 bits, every predictor reads 12.003, and the measured gain is exactly zero.
Lossy coding tells a different story, but only on one kind of data. Tested on two corpora that postdate any plausible training cutoff, 2026 hourly demand from 49 US grid balancing authorities and 2026 hourly ridership from 50 New York subway stations, Cadence beats the best classical predictor by a median +13.3% on grid load (147/147 wins) and +28.3% on ridership (150/150 wins), for +21.4% median across all 297 series-tolerance pairs, winning every one. Mixed operational telemetry gains only +6.4%, synthetic signals +2.9%. The team then tried to falsify the domain claim on SDRBench, a scientific-simulation benchmark, and the theory predicted failure and got it: -0.8% median, 0 of 27 pairs gaining, deepening to -41% on a smooth hurricane simulation field.
| Corpus | Median gain | Wins |
| Grid load (2026) | +13.3% | 147/147 |
| Subway ridership (2026) | +28.3% | 150/150 |
| Mixed operational telemetry | +6.4% | 21/24 |
| Synthetic signals | +2.9% | 7/12 |
| SDRBench (scientific) | -0.8% | 0/27 |
Two engineering findings are easy to miss but matter for deployment. First, the model's predictions aren't bit-identical across batch sizes (desync probability roughly 8x10^-6 per sample, near-certain over a million samples), so the batch/group size has to be baked into the container format rather than fixed after the fact. Second, a neural codec has to pay a context-bootstrap cost a classical predictor doesn't, which shrinks end-to-end gains well below the headline numbers: +6.8% on six months of hourly data, rising to +15.1% only asymptotically. Against downsampling, what production time-series databases actually deploy for retention, Cadence's guaranteed worst-case error is 28-56x tighter at equal file size, which the authors argue is the strongest practical case for the whole approach, stronger than beating scientific compressors like SZ3.
This is a clean counterpoint to the instinct that a bigger pretrained model should help everywhere. The log2 law gives a checkable rule: a foundation model only helps compression when the classical predictor is already weak and the coding regime is error-bounded lossy, where a residual landing inside the tolerance band costs zero bits, a discontinuity that escapes the logarithmic law entirely. In practice that combination shows up in aggregate human-demand data, not numeric time series generally. For teams building time-series storage systems, the realistic comparison point isn't a scientific compressor but the downsampling every production database already uses, which offers no error bound at all.
The authors report their own full list of failures: cross-series conditioning through covariates makes coding worse rather than better; using the foundation model to interpolate smooth grids fails outright, down to -210% in some settings; per-block hybrid switching between predictors yields zero net gain because TimesFM-3 already dominates the classical causal predictor with nothing left to hybridize. Throughput is 224 values/second in fp32, orders of magnitude slower than classical codecs, so this is strictly an archival codec. The 1.3GB model carries a non-commercial license and needs roughly 54GB of payload to amortize its own weight if shipped as a self-contained archive. Portability is a real, measured problem: the same model run on GPU versus CPU doesn't produce bit-identical predictions, and a five-year hourly archive has roughly a 26% failure probability from that alone. The positive result rests on exactly two corpora, and the authors explicitly say it doesn't extend to physical sensors, smooth simulation fields, or random-walk-like financial series.