Abstract

We ask whether a pre-trained time-series foundation model reduces the bit cost of numeric data, and find that the answer depends entirely on the coding regime and the data domain. For lossless coding the answer is no, and the reason is structural rather than an engineering deficit: code length depends on the logarithm of predictor accuracy, so the 1.51$\times$ accuracy advantage TimesFM-3 [11] holds over a 32-tap linear predictor on real data buys $0.60$ bits out of $20.28$, or $2.9\%$. Measured against classical predictors under an identical entropy coder, TimesFM-3 yields a median gain of $+0.03\%$ across 12 series—nil. For error-bounded lossy coding the picture reverses on one specific class of data. We introduce Cadence, a closed-loop codec that guarantees $\left|{\hat{x}}_t-x_t\right|\le \tau$ per sample, and evaluate it on two uncontaminated corpora postdating any plausible training cutoff: 49 US balancing-authority hourly demand series (EIA-930, 2026) and 50 MTA subway station hourly ridership series (2026). Against the best of six classical error-bounded predictors—every predictor coded by the same adaptive arithmetic coder we implement—Cadence achieves a median gain of $+13.3\%$ (147/147) on grid load and $+28.3\%$ (150/150) on ridership—+21.4% median over 297 series-tolerance pairs, winning all 297. The same codec gains only $+6.4\%$ (21/24) on mixed operational telemetry and $+2.9\%$ on synthetic signals, locating the effect in aggregate human-demand series rather than in numeric data generally. We report five results that constrain how such systems must be built and measured. (1) The log₂ law explains why forecasting improvements do not transfer to lossless compression. (2) Batch-size invariance is unattainable: no PyTorch configuration we tested makes predictions bit-identical across batch sizes, so group size must be part of the container format; we verify a bit-exact round trip under this constraint. (3) The context bootstrap is a cost unique to neural codecs and dominates short archives: end-to-end gains are $+6.8\%$ at six months of hourly data, rising to $+15.1\%$ asymptotically, well below body-only figures. (4) The model’s quantile head contributes nothing beyond its median, context length is worth $\sim$1 point, and a general-purpose entropy back end is not neutral—replacing xz/zstd with our coder gains $+9.7\%$ and reverses one apparent finding. (5) Against downsampling—what time-series databases actually deploy—Cadence delivers a worst-case error $28$–$56\times$ tighter at equal file size, which we argue is the strongest practical case for the approach. We test the domain claim by attempting to falsify it on SDRBench, where the theory predicts failure and delivers it: $-0.8\%$ median, $0/27$, deepening to $-41\%$ on a smooth simulation field.

Keywords: lossy compression, error-bounded compression, time-series foundation models, scientific data reduction, time-series databases

Code and data: https://github.com/robtacconelli/Cadence

1. Introduction

Shannon [22] established that compression is prediction: a model assigning high probability to the next symbol lets an encoder spend fewer bits on it. Recent work has pushed this to large neural models, with Delétang et al. [7] showing that a 70B language model compresses text below classical context-mixing systems, and practical implementations following [5, 19, 23].

Time-series foundation models—TimesFM [6, 11], Chronos [3], Moirai [29]—are the analogous development for numeric sequences. They are pre-trained on trillions of time points and forecast unseen series zero-shot. If compression is prediction, a model that forecasts electricity demand better than a linear filter should compress it better. This paper tests that inference and finds it substantially false in the lossless case, and true only within a narrow domain in the lossy case.

The negative result has a clean form. Code length under a well-matched residual model is $\phantom{}\approx {\log }_2\left(\text{residual scale}\right)+c$, so the bits saved by a better predictor are logarithmic in the accuracy ratio:

$\Delta \text{bits}={\log }_2\left(\frac{{\mathrm{MAE}}_{\text{old}}}{{\mathrm{MAE}}_{\text{new}}}\right).$

(1)

On real hourly pageview data, TimesFM-3 attains $\mathrm{MAE}=\mathrm{113,608}$ against $\mathrm{171,507}$ for a 32-tap least-squares LPC—a genuine $1.51\times$ improvement—which Eq. 1 converts into $0.597$ bits out of $20.28$, i.e. $2.9\%$. Halving a 20-bit-per-value file would require a $\sim$$1000\times$ better forecaster. This single identity is sufficient to rule out the lossless neural entropy coder, and with it per-file adaptation, retrieval-augmented context, and lossless float coding, all of which route their gain through a smaller residual. Figure 1 shows the relationship together with the three measured operating points.

媒体内容 · 前往原文查看

Error-bounded lossy coding escapes Eq. 1 at one point: when the forecast lands inside the tolerance band the quantized residual is exactly zero and the sample costs $\approx$0 bits. That is a discontinuity, not a logarithm. We therefore build Cadence, a closed-loop error-bounded codec, and evaluate it against the predictors that state-of-the-art scientific compressors actually use—the Lorenzo family and multilevel interpolation of SZ3 [16], and ZFP [17].

1. The log₂ law as a design constraint. We formalize why forecasting accuracy transfers only logarithmically into lossless compression and verify it numerically, explaining a $+0.03\%$ median result that would otherwise look like an implementation failure.

2. An identical-coder evaluation protocol. Comparing a neural predictor against a classical one is only meaningful if both residuals pass through the same entropy coder. We route every predictor through one adaptive mixture-of-scales coder, and validate the harness on i.i.d. noise, where all predictors read $12.003$ bits/value against a true entropy of $12.000$ and the measured gain is exactly $+0.00\%$. An earlier version of our harness reported a $+2.15\%$ “gain” on pure noise—an artifact of comparing a flexible piecewise-linear density against a Laplace.

3. Domain localization on uncontaminated data. TimesFM-3 is pre-trained on Wikipedia pageviews and Google Trends, so the obvious benchmarks are contaminated. We evaluate on two corpora postdating any plausible cutoff and show the gain is a property of aggregate human-demand series ($+21.4\%$, 297/297), not of numeric data ($-3.4\%$ synthetic, $+5.2\%$ mixed telemetry).

4. A determinism constraint for neural codecs. We show that model predictions are not bit-identical across batch sizes and that no configuration we tested (TF32 disabled, SDPA disabled, deterministic algorithms, forced MATH backend) repairs this. Encoder–decoder desynchronization probability is $\sim$$8\times {10}^{-6}$ per sample, negligible per sample and near-certain over a million. Group size must therefore be part of the container format; we verify a bit-exact round trip under that rule.

5. Context-bootstrap accounting. A neural codec must transmit $c$ samples of context that a Lorenzo predictor does not need. We price it, show it dominates short archives, and report end-to-end rather than body-only gains.

6. Ablations. Context length is worth $\sim$1 point, and the nine quantiles—TimesFM-3’s only probabilistic output—contribute $+0.3\%$ beyond their median, so the codec can discard them.

7. An adaptive arithmetic coder, and evidence that the back end is not neutral. We implement a binary range coder with context-modelled binarization of quantization indices. It beats xz/zstd on real indices by $+9.7\%$ (15/15), so general-purpose-back-end results understate neural and classical predictors alike; more importantly it reverses an apparent finding (Section 5.2) and re-explains a negative result (Section 5.9) we had attributed to the wrong cause.

8. Comparison against deployed practice. Time-series databases retain history by downsampling, which has unbounded $L_{\infty }$ error. At equal file size Cadence’s guaranteed bound is $28$–$56\times$ tighter.

9. Three negative results. Cross-series conditioning through covariates, foundation-model interpolation, and per-block hybrid switching all fail; we report why, since two of the three fail for the same measurable reason.

2. Related Work

2.1 Error-Bounded Lossy Compression

SZ [8] and its successor SZ3 [16] dominate error-bounded scientific compression. Both quantize a prediction residual and entropy-code the index. Critically, their predictors are small: the Lorenzo stencil [12] of order 1–3, linear regression, and in SZ3 the hierarchical, anchor-based level-wise dynamic spline interpolation of Zhao et al. [30], subsequently auto-tuned in QoZ [28]. Our classical baseline family reimplements exactly these predictors so that the comparison isolates prediction quality. ZFP [17] instead applies a block transform, and FPZIP [18] targets lossless float coding. MGARD [1] provides multigrid error control. SDRBench [31] is the standard corpus. This literature is overwhelmingly aimed at multidimensional simulation fields; 1-D operational telemetry is not its design target, a point that matters when interpreting our SZ3 comparison.

2.2 Time-Series Compression in Databases

Gorilla [21] introduced XOR-based lossless float compression for monitoring workloads and remains the basis of most production time-series databases; Chimp [27] and Elf [26] refine its XOR coding, and Sprintz [24] targets integer IoT streams with delta coding and bit packing. Chiarot and Silvestri [25] survey the area. For long-term retention these systems do not use error-bounded codecs at all: they downsample to coarse aggregates. This discards extrema, which is precisely the information incident analysis needs, and it provides no worst-case guarantee. We treat downsampling as the operative baseline for the retention use case.

2.3 Time-Series Foundation Models

TimesFM [6] introduced a decoder-only patched transformer for zero-shot forecasting; TimesFM-3 [11] extends it to native multivariate forecasting with 0.3B parameters trained on over a trillion time points, using stacked variate attention and iterative reversible instance normalization [13]. It emits nine quantiles ($0.1$–$0.9$) per horizon step and decodes a 64-step horizon non-autoregressively. Chronos [3] and Moirai [29] are contemporaneous. Forecasting quality is well studied; the compression consequences are not, which is the gap this paper addresses.

2.4 Neural Compression

NNCP [4] and CMIX [14] established that online adaptation plus arithmetic coding yields state-of-the-art lossless ratios at very low throughput. LLM-based text compressors [7, 5, 19, 23] extend this to pre-trained models. Our lossless finding is consistent with that literature and with Eq. 1: text gains are large because language models are orders of magnitude better than order-$k$ context models, whereas TimesFM-3 is only $1.5\times$ better than a linear filter.

3. Method

3.1 Problem Setup

Given an integer-valued series $x{}_{1:n}$ and an absolute tolerance $\tau$, an error-bounded codec must emit a bitstream from which a decoder reconstructs $\hat{x}{}_{1:n}$ with

$\left|{\hat{x}}_t-x_t\right|\le \tau \forall t.$

(2)

We set $\tau =\rho \sigma \left(x\right)$ and sweep $\rho \in \left\{0.01,0.05,0.2\right\}$. Note that $\rho$ maps to very different relative errors by domain: $\rho =0.05$ is $1.1\%$ on grid load but $4.5\%$ on station ridership, so comparisons across domains should be made at matched relative error.

3.2 Closed-Loop Quantization

With quantization step $D=2\tau$ and predictor $P$,

	$p_t$	$=P\left({\hat{x}}_{t-c:t-1}\right),k_t=\lceil \frac{x_t-p_t}{D}\rfloor ,$		(3)
	${\hat{x}}_t$	$\phantom{}=p_t+k_{t}D,$		(4)

which satisfies Eq. 2 by construction. The predictor is fed its own reconstruction, never the original, so the decoder can reproduce $p_t$ exactly. This closed loop is what makes the neural predictor’s behaviour under injected quantization noise relevant (Section 5.4).

3.3 Neural Predictor

$P$ is TimesFM-3 with context $c$ and horizon 64, of which only the first step is used, giving stride-1 operation. We take the median (quantile index 4) as the point forecast. Section 5.9 shows the other eight quantiles are not worth transmitting, so we call the model with quantile output disabled.

3.4 Group Size as a Format Parameter

Because model outputs are not bit-identical across batch sizes (Section 5.6), the format fixes a group size $G$; encoder and decoder both run batches of exactly $G$. This is natural for a time-series database, which compresses a block of $G$ metrics together in the manner of a columnar block, but it does mean that decoding one series costs a full group. We note that snapping predictions to a coarse grid does not solve this: it relocates the decision boundary rather than removing it, and a coarser grid has more boundary per unit of drift.

3.5 Context Bootstrap

The model needs $c$ samples of history before it can predict, whereas a Lorenzo-1 predictor needs one. Cadence codes those $c$ samples lossily at the same $\tau$ using the best of five side-information-free classical predictors—Lorenzo orders 1–3, multilevel linear and cubic interpolation—selecting per series and storing a one-byte identifier. LPC-32 is excluded because its least-squares coefficients would have to be transmitted. The encoder then feeds the reconstructed seed as model context so that encoder and decoder share history from sample 0.

3.6 Entropy Coding

Quantization indices are coded by an adaptive binary range coder (LZMA-style, 11-bit probabilities) with a CABAC-like binarization: a context-coded zero flag, a bypass sign, a context-coded truncated-unary magnitude prefix, and an Exp-Golomb bypass tail. Contexts derive from recent magnitudes and are reproducible by the decoder, so nothing about them is transmitted. Crucially, conditioning is expressed as contexts within one stream rather than as separate streams, so no partitioning can fragment the coder—a failure mode that invalidated two of our earlier experiments. The coder was validated by round-tripping Laplacian, sparse, heavy-tailed, all-zero and uniform inputs. All reported figures are real bytes, and every predictor—neural and classical—is coded by this same coder, so comparisons remain comparisons of predictors. Section 5.9 reports idealized code lengths where they isolate a modelling question, but never as headline results—in this study every idealized figure proved optimistic relative to real bytes.

媒体内容 · 前往原文查看

0:  series $x{}^{(1..G)}$, tolerances $\tau {}^{(1..G)}$, context $c$

1:  for $g=1$ to $G$ do

2:   $s^{\left(g\right)}\leftarrow \arg {\min }_{P\in 𝒮}\left|\text{code}(P,x_{1:c}^{\left(g\right)},{\tau }^{\left(g\right)})\right|$

3:   ${\hat{x}}_{1:c}^{\left(g\right)}\leftarrow \text{reconstruct}\left(s^{\left(g\right)}\right)$ {lossy seed at the same $\tau$}

4:  end for

5:  for $t=c+1$ to $n$ do

6:   $p_{1:G}\leftarrow TimesFM-3\left({\left\{{\hat{x}}_{t-c:t-1}^{\left(g\right)}\right\}}_{g=1}^G\right)$ {one batched pass of exactly $G$}

7:   for $g=1$ to $G$ do

8:    $D\leftarrow 2{\tau }^{\left(g\right)}$;  $k_t^{\left(g\right)}\leftarrow \lceil \left(x_t^{\left(g\right)}-p_g\right)/D\rfloor$

9:    ${\hat{x}}_t^{\left(g\right)}\leftarrow p_g+k_t^{\left(g\right)}D$

10:   end for

11:  end for

12:  return header $\parallel$ seeds $\parallel$ pack-and-compress$\left(k^{\left(g\right)}\right)$

4. Experimental Setup

4.1 Hardware and Software

All experiments run on a single NVIDIA RTX 5060 (8 GB) with PyTorch 2.12 [2] and timesfm 3.0.0. We note that the TimesFM-3 model card supplies no separate citation for the third-generation model: its BibTeX entry still points to the original decoder-only paper [6], so we cite that work for the architecture lineage and the model card and release note [11] for TimesFM-3-specific details. TimesFM-3 weights are 1.3 GB and use 1.4–1.9 GB of VRAM at the batch sizes reported. SZ3 is built from source; ZFP is zfpy 1.0.1. All figures are fp32; Section 5.8 discusses bf16.

4.2 Baselines

Our primary bar is the best of six classical error-bounded predictors, each run closed-loop at the same $\tau$ with the identical entropy coder: Lorenzo orders 1–3, a 32-tap least-squares LPC, and multilevel linear and cubic interpolation. Best-of-six is selected per row, so the baseline is the strongest classical result available rather than an average. We additionally report the real SZ3 and ZFP binaries end-to-end, and downsampling with linear reconstruction. We do not report xz as a lossy comparator: it is lossless and the comparison would be meaningless.

4.3 Corpora

Synthetic (10 series $\times$ 20k samples) includes deliberate controls: i.i.d. uniform noise, whose entropy any correct harness must reproduce, and a random walk. NAB [15] supplies 8 real operational series (EC2 CPU/network/disk, RDS, autoscaling, NYC taxi, ambient and machine temperature). Grid is EIA-930 [10] hourly demand for 49 US balancing authorities, January–June 2026. Transit is MTA hourly ridership [20] for the 50 busiest station complexes, January–August 2026.

Contamination control. TimesFM-3 is trained on Wikipedia pageviews (to November 2023) and Google Trends, so results on such series cannot support a generalization claim. Grid and Transit both postdate any plausible cutoff and carry the headline domain result. One balancing authority (SEC) is excluded as corrupt: 3 of 4,343 samples carry sentinel values near $-4.3\times 10{}^8$ in a $\sim$300 MW series, which inflates $\tau =\rho \sigma$ absurdly.

4.4 Reproducibility

All code, the experiment registry, and the JSON results behind every number in this paper are available at https://github.com/robtacconelli/Cadence under an MIT licence. Result files are committed, so every figure and table can be regenerated without a GPU; scripts to rebuild each corpus from its primary source are included. TimesFM-3 weights are not redistributed: they carry a non-commercial licence, which this pipeline inherits.

5. Results

5.1 Lossless Coding Does Not Benefit

Table 1 reports stride-1 lossless coding with every predictor routed through one adaptive coder. The median gain over the best classical predictor is $+0.03\%$ across 12 series, with 7/12 nominal wins of negligible size.

媒体内容 · 前往原文查看

Series	xz	Classic	TimesFM-3	Gain
ecg_like	9.586	7.999	7.094	$+11.3\%$
sparse_spiky	11.818	9.276	9.078	$+2.1\%$
wikihr_en	23.858	19.758	19.288	$+2.4\%$
wikihr_de	21.733	17.462	17.074	$+2.2\%$
regime_switch	13.413	12.151	12.100	$+0.4\%$
poisson_counts	4.035	3.608	3.606	$+0.1\%$
seasonal_metric	15.611	12.399	12.417	$-0.2\%$
random_walk	14.290	10.719	10.727	$-0.1\%$
iid_noise	12.736	12.003	12.003	$+0.00\%$
byte_counter	17.379	8.099	8.219	$-1.5\%$
lorenz_chaotic	15.389	3.005	3.054	$-1.6\%$
Median	—	—	—	$+0.03\%$

The iid_noise row validates the harness: true entropy is ${\log }_{2}4096=12.000$, every predictor reads $12.003$, and the gain is exactly zero. This row is why we trust the rest of the table. It is also how we caught an earlier harness defect that reported $+2.15\%$ on pure noise, which arose from giving TimesFM-3 a flexible piecewise-linear density while the baseline was locked to a Laplace—a measurement of density family, not of skill.

Eq. 1 accounts for the outcome. On wikihr_en, TimesFM-3 achieves $\mathrm{MAE}=\mathrm{113,608}$ versus $\mathrm{171,507}$ for LPC-32, a $1.513\times$ improvement worth ${\log }_{2}1.513=0.597$ bits of a $20.28$-bit budget.

5.2 Error-Bounded Lossy Coding, by Domain

Table 2 summarizes all lossy evaluations under real-byte accounting. The effect is sharply localized.

媒体内容 · 前往原文查看

Corpus	Median	Wins	Contam.
SDRBench (sci.)	$-0.8\%$	0/27	n/a
Synthetic	$+2.9\%$	7/12	n/a
NAB operational	$+6.4\%$	21/24	no
Grid load (2026)	$+13.3\%$	147/147	no
Transit (2026)	$+28.3\%$	150/150	no
Demand combined	$+21.4\%$	297/297	no

Figure 2 shows the full distribution behind Table 2: the two demand corpora separate cleanly from the others, and their spread sits almost entirely above zero rather than being carried by a tail.

媒体内容 · 前往原文查看

Tables 3 and 4 give the tolerance breakdown. All 297 series-tolerance pairs gain—a clean sweep in both domains—and gains grow with tolerance in both, which is what the mechanism predicts: the advantage arises from the discontinuity at zero residual, so it should compound as the band widens.

We initially reported the opposite for grid load, with gains apparently shrinking in $\rho$ ($+21.3\%$, $+14.0\%$, $+13.9\%$). That was an artifact of the general-purpose back end: at loose tolerance a simple predictor emits long runs of zeros, which LZMA compresses extremely well, flattering the classical baseline exactly where Cadence should pull ahead. With the arithmetic coder the trend inverts. We report this because the retracted version is the more publishable-looking result, and because it shows that delegating residual coding to a generic compressor can manufacture a qualitative finding.

媒体内容 · 前往原文查看

$𝝆$	Median	Wins	Classic	Cadence
0.01	$+6.4\%$	49/49	4.356	4.009
0.05	$+13.3\%$	49/49	2.398	2.056
0.20	$+21.2\%$	49/49	1.265	0.980
All	$+13.3\%$	147/147

媒体内容 · 前往原文查看

$𝝆$	Median	Wins	Classic	Cadence
0.01	$+19.9\%$	50/50	5.942	4.734
0.05	$+27.7\%$	50/50	3.324	2.374
0.20	$+51.2\%$	50/50	1.834	0.926
All	$+28.3\%$	150/150

Figure 3 plots the resulting rate–distortion curves against guaranteed error rather than against $\rho$, which is the comparable axis across domains.

媒体内容 · 前往原文查看

Against the real SZ3 binary the median gain is $+36.3\%$, but this should be read carefully: our own classical predictors also beat SZ3 on these data. The honest reading is that SZ3, designed for multidimensional simulation fields, is not the right tool for 1-D operational telemetry. Best-of-six at $+13.3\%$ is the defensible bar. We also note that SZ3 carries roughly 500 B of container overhead, which dominates below $N\approx 4$k; an earlier version of this comparison at $N=2048$ overstated our advantage by a wide margin.

5.3 SDRBench: A Falsification Test

Section 5.2 claims the effect belongs to demand series rather than to numeric data. That claim predicts Cadence should lose on scientific simulation output, where smooth fields make a local or interpolating predictor near-optimal. We ran SDRBench [31] to try to falsify it: six EXAALT molecular-dynamics trajectories and three Hurricane ISABEL scanlines, evaluated 1-D against 1-D so that the comparison between predictors remains fair.

媒体内容 · 前往原文查看

Subset	Median	Wins	vs. $\rho$
EXAALT (MD traj.)	$-0.6\%$	0/18	flat
Hurricane (smooth)	$-25.4\%$	0/9	deepens
All SDRBench	$-0.8\%$	0/27

Table 5 shows the prediction holds: not one of the 27 field-tolerance pairs gains. EXAALT trajectories, which are noisy and effectively 1-D, are close to break-even ($-0.6\%$ median). Hurricane scanlines lose heavily, and the loss grows with tolerance ($-3.5\%$, $-25.4\%$, $-41.0\%$ at $\rho =0.01,0.05,0.2$)—precisely inverted from ridership, where gains grow with tolerance. Set against $+21.4\%$ on demand series, this makes the domain characterization a tested boundary rather than an observation.

We note two caveats. Our codec is 1-D and cannot exploit the multidimensional structure SZ3 is built for, so these numbers say nothing about SZ3 in its native mode. And within this 1-D setting both Cadence and our classical family beat SZ3 by a wide margin, which again indicates that SZ3 in 1-D is being used outside its design envelope.

5.4 Predictor Behaviour Under Feedback Noise

Because the closed loop feeds each predictor its own reconstruction, injected quantization noise propagates. We measure the gain $G=\mathrm{std}\left(P\left(x+ϵ\right)-P\left(x\right)\right)/\mathrm{std}\left(ϵ\right)$. Analytically, Lorenzo-1 has $G=1$, Lorenzo-2 $\sqrt{5}\approx 2.24$, Lorenzo-3 $\sqrt{19}\approx 4.36$, midpoint-linear interpolation $\sqrt{0.5}\approx 0.707$ and 4-point cubic $0.80$. Measured, TimesFM-3 has $G\in \left[0.27,2.12\right]$ and LPC-32 up to $5.44$.

A simple model, ${\text{err}}_{\text{tot}}^2={\text{err}}_{\text{clean}}^2+{\left(G{\sigma }_{ϵ}\right)}^2$, predicts the win/loss sign in 15 of 18 cases, including a full reversal on the Lorenz system where TimesFM-3 is $26.7\times$ less accurate on clean data yet wins at large $\tau$. We stress the conclusion this does not support: TimesFM-3 is not contractive, whereas SZ3’s interpolation is contractive by construction. Noise robustness is therefore not an unexploited gap—the field already exploits it, and better. Against multilevel cubic interpolation TimesFM-3 loses on Lorenz at every tolerance.

5.5 End-to-End Codec and the Context Bootstrap

Cadence round-trips bit-exactly at $G=8$ and $G=16$: decoder reconstructions match encoder reconstructions by SHA-256 and Eq. 2 holds on every series. Table 6 decomposes the container.

媒体内容 · 前往原文查看

Component	bpv
Seed ($c=512$, coded lossily)	0.412	20%
Body (3,788 samples)	1.906	80%
Total	2.111	15.2$\times$

The bootstrap is a cost the classical baseline does not pay, and it dominates short archives. Table 7 shows the consequence: body-only figures of $+13.3\%$ become $+6.8\%$ on six months of hourly data, converging to $+15.1\%$ asymptotically.

媒体内容 · 前往原文查看

Length	Span	Best $c$	Gain
4,300	6 months	512	$+6.8\%$
8,760	1 year	512	$+11.0\%$
17,520	2 years	512	$+13.0\%$
43,800	5 years	512	$+14.2\%$

5.6 Determinism

Table 8 reports whether predictions are bit-identical across call configurations. Repetition and batch reordering are safe; batch size is not, and no configuration we tried repairs it.

媒体内容 · 前往原文查看

Condition	Identical	Max diff
Same batch, repeated $\phantom{}\times 3$	yes	$0$
Batch reordered	yes	$0$
Batch 1 vs. batch 8	no	$3.9\times {10}^{-3}$
Batch 8 vs. batch 9	no	$7.8\times {10}^{-3}$
+ TF32 disabled	no	$7.8\times {10}^{-3}$
+ use_sdpa=False	no	$7.8\times {10}^{-3}$
+ deterministic algorithms	no	$7.8\times {10}^{-3}$
+ forced MATH backend	no	$2.0\times {10}^{-3}$

With $D=985$ MW at $\rho =0.05$ on MISO and a maximum drift of $7.8\times {10}^{-3}$ MW, the probability that a sample sits close enough to a bin edge to flip is $\phantom{}\approx 8\times {10}^{-6}$. That is negligible per sample and near-certain across a million, and a single desynchronization destroys every sample after it. Hence Section 3.4.

Cross-device portability. We cannot test two machines, but we can test something strictly harder on one: the same model and inputs executed on GPU versus CPU. They are not bit-identical (max $3.9\times {10}^{-3}$ MW, 3/8 series). At $\rho =0.05$ that drift is $7.0\times {10}^{-6}$ of a quantization step, giving an expected $\approx$$1.44\times {10}^5$ samples before the first desynchronization: a six-month hourly series usually survives, a five-year archive fails with probability $\approx$$26\%$, and beyond $\approx$$144$k samples failure is effectively certain. The container must therefore record the execution device as well as the group size. The obvious remedy—fp64—is unavailable without patching the inference library, which pins its tensors to fp32.

5.7 Comparison with Deployed Retention Practice

At matched file size we compare against downsampling with linear reconstruction, the mechanism production databases actually use. Downsampling’s worst-case error relative to Cadence’s guaranteed bound is $28.0\times$ (grid), $36.7\times$ (NAB) and $56.1\times$ (transit) at the median. Downsampling does not claim an $L_{\infty }$ bound, so the fair statement is narrow: wherever worst-case fidelity matters—incident forensics, anomaly detection, compliance retention—downsampling is the wrong instrument and an error-bounded codec is strictly better at the same cost.

5.8 Throughput

Table 9 shows that our initial throughput figure was an artifact of batching, not a property of the model. Every (series, tolerance) pair is an independent closed loop, so they advance in lockstep on one forward pass.

媒体内容 · 前往原文查看

Batch	Ctx	Prec.	Values/s
6	1024	fp32	45
64	1024	fp32	113
256	1024	fp32	123
256	512	fp32	224
256	512	bf16	442

We report fp32 throughout. bf16 roughly doubles throughput but perturbs predictions by $288$ MW against a model error of $565$ MW—$51\%$—which would inflate residuals by roughly $12\%$. Encoder and decoder would still agree, since both follow the same path, so bf16 remains viable for deployment; we simply decline to conflate a speed choice with a compression result.

5.9 Ablation Study

媒体内容 · 前往原文查看

Ctx	Body	$\Delta$ body	Seed	$n=4300$	$n=43800$
64	2.183	$-11.6\%$	6.367	$-0.0\%$	$+2.5\%$
128	2.071	$-5.9\%$	4.582	$+4.4\%$	$+7.4\%$
256	2.017	$-3.1\%$	3.611	$+5.9\%$	$+9.7\%$
512	1.959	$-0.2\%$	3.214	$+6.0\%$	$+12.0\%$
1024	1.956	—	2.980	$+2.0\%$	$+11.8\%$

媒体内容 · 前往原文查看

Context length (Table 10 and Figure 4) is worth about two points at long archive lengths. We had expected a large effect, reasoning that a shorter bootstrap costs proportionally less; in fact body accuracy degrades about as fast as seed cost falls, and $c=512$ is optimal at every length we tested. The practically useful observation is different: accuracy saturates early, so $c=256$ costs only $3.1\%$ against $c=1024$ while quartering inference cost. That is a systems result, not a compression one.

The quantile head contributes essentially nothing. Conditioning the residual model on the predicted spread—the natural use of TimesFM-3’s nine quantiles—yields a median $+0.3\%$ (10/15 configurations) and is negative at $\rho =0.2$. A flat adaptive coder already tracks the residual scale causally, and predicted spread varies slowly enough to add no information. The codec can therefore disable quantile output entirely.

We tested this three ways, and the diagnosis changed. Splitting the index stream into eight spread buckets and compressing each separately reads $-66.3\%$ (0/15), which measures fragmentation rather than modelling. Idealized code lengths give $+0.3\%$. But expressing spread as contexts inside one arithmetic-coded stream—where fragmentation is impossible by construction—still gives $-13.8\%$ (0/15). The cause is therefore not fragmentation but context dilution: splitting the adaptive model across eight contexts slows convergence more than the conditioning gains, and predicted spread carries no information beyond the recent-magnitude context already in use. Three independent implementations agree, and only the third identifies the mechanism.

5.10 Negative Results

Cross-series conditioning. TimesFM-3 accepts covariates spanning context and horizon. Conditioning en.wikipedia hourly views on de.wikipedia—supplying the full trajectory of a correlated series—moved code length from $19.045$ to $19.054\text{bpv}$, despite reducing MAE from $113.6$k to $111.4$k.

Foundation-model interpolation. Since anchored interpolation beats extrapolation on smooth signals, we coded a coarse grid, upsampled its reconstruction, and supplied it as a past-and-future covariate. This failed in every configuration tested ($K\in \left\{8,16\right\}$, stride $\phantom{}\in \left\{32,64\right\}$, $\rho \in \left\{0.01,0.05\right\}$), from $-0.7\%$ to $-210\%$. Together with the previous result this is two independent failures of the covariate pathway, and we provisionally conclude it is not a usable side-information channel for coding.

Hybrid prediction. We resolved this with a design that needs no side information at all. Because the decoder holds the same reconstructed history, it can recompute a causal classical prediction and both predictors’ error histories itself; a switch therefore costs zero bits. We ran three closed loops—TimesFM-3 alone, a causal inverse-error blend, and leader (use whichever predictor won the previous 256-sample block)—each producing a single index stream, so fragmentation is impossible. leader selects TimesFM-3 in $100\%$ of blocks and degenerates exactly to TimesFM-3 alone; blend is worse ($2.432$ vs. $2.221\text{bpv}$ at $\rho =0.05$), since averaging with a weaker predictor hurts. The net gain is $+0.0\%$: on this domain the model dominates the causal classical predictor uniformly and there is nothing to hybridize. Our earlier $-4.0\%$ was entirely fragmentation. leader is nonetheless worth shipping as free insurance—it costs nothing and degenerates correctly off-domain, which Section 5.3 shows is a real operating regime.

6. Discussion

6.1 Why Demand Series

The winning corpora share a generative structure: they are aggregate counts of many independent human decisions, sampled at 30-minute to hourly resolution, with strong daily and weekly periodicity. The losing corpora are per-machine physical and resource metrics—temperature, CPU load, disk throughput—where a one- or two-tap predictor is already near-optimal and there is nothing for a pre-trained model to contribute. This is consistent with Eq. 1: gains require a large accuracy ratio, and such ratios only arise where the classical predictor is genuinely weak. SDRBench (Section 5.3) marks the far end of that spectrum: on a smooth simulation field the classical predictor is near-optimal, and Cadence loses by up to $41\%$.

We tried and failed to find a cheap statistic that predicts membership. Neither the ratio of local to long-lag classical code length ($r=-0.37$) nor daily-versus-lag-1 autocorrelation ($r=+0.44$, $n=49$) separates winners from losers reliably. Practitioners should measure on a sample of their own data rather than rely on a proxy.

6.2 On Reporting Discipline

Every idealized or projected number in this study came in high when re-measured as real bytes end-to-end. Idealized code lengths overstated gains by roughly a quarter; a projected $+9.9\%$ end-to-end figure measured $+2.9\%$; a domain gain of $+15\%$ inferred from an idealized coder measured $-12.9\%$. We recommend that work in this area report real bytes and treat idealized code lengths strictly as upper bounds. A second discipline follows from Section 5.2: the entropy back end is part of the experimental design. Delegating residual coding to xz or Zstandard understated every predictor here by $\approx$$10\%$ and manufactured a qualitative tolerance trend that reversed under a real coder.

6.3 Limitations

1. Throughput. At 224 values/s (fp32) compression is orders of magnitude slower than classical codecs, which run at MB/s. Cadence is an archival codec. Decoding is strictly sequential and equally slow.

2. Model overhead. The 1.3 GB model must be present at both endpoints, and its weights carry a non-commercial licence. As with all neural compressors we treat it as a shared standard; a self-contained archive would need $\sim$54 GB of payload to amortize it.

3. Group-size coupling. Section 5.6 forces $G$ into the format, so decoding a single series costs a full group. This is acceptable for columnar database blocks and awkward otherwise.

4. Deliverable gain is modest. End-to-end gains are $+6.8\%$ at six months and $+14.2\%$ at five years. The larger body-only figures measure the model’s predictive advantage, not file size.

5. Domain narrowness. Two demand corpora support the result. It does not extend to physical sensors, smooth simulation output, or random-walk-like financial series, and we have no verified evidence for retail, call-centre or utility-metering data.

6. Bitstream portability. Measured, not merely suspected: GPU and CPU execution disagree, and the resulting desynchronization rate implies a five-year hourly archive fails with probability $\approx$$26\%$ (Section 5.6). Portability requires integer or fixed-point inference, which the current library does not support.

6.4 Future Work

Integer or fixed-point inference would make the bitstream portable across hardware and remove the group-size constraint, which is the main obstacle to deployment. Distilling a small student to imitate the median forecast would address throughput, though Eq. 1 caps what it can recover. An asymmetric-numeral-systems back end [9] would raise coding throughput over our binary range coder without changing the model. Finally, the downsampling comparison suggests the most useful framing is not competition with SZ3 but replacement of lossy retention tiers in time-series databases, which would benefit from evaluation inside a real database engine.

7. Conclusion

Forecasting accuracy and compression are related logarithmically, not linearly, and that single fact determines where a time-series foundation model can help. For lossless coding it cannot: a $1.5\times$ better forecaster buys $0.6$ bits of a $20$-bit budget, and we measure a median gain of $+0.03\%$. For error-bounded lossy coding on aggregate human-demand series it can: Cadence achieves $+21.4\%$ over the best of six classical predictors across 297 series-tolerance pairs on two uncontaminated 2026 corpora, winning all 297. The deliverable end-to-end gain is smaller, $+6.8\%$ at six months rising to $+15.1\%$ asymptotically, once the context bootstrap is paid for. The strongest practical case is not against scientific compressors at all but against downsampling, the mechanism time-series databases actually deploy, where Cadence offers a worst-case error $28$–$56\times$ tighter at equal size. Code, data pipeline and the full experiment registry—including the eight claims we retracted under better measurement—are at https://github.com/robtacconelli/Cadence.

References

• [1] Ainsworth, M., Tugluk, O., Whitney, B., and Klasky, S. (2019). Multilevel techniques for compression and reduction of scientific data. SIAM Journal on Scientific Computing, 41(4):A2146–A2171.
• [2] Ansel, J., Yang, E., He, H., et al. (2024). PyTorch 2: Faster machine learning through dynamic Python bytecode transformation and graph compilation. In ASPLOS ’24.
• [3] Ansari, A. F., Stella, L., Turkmen, C., et al. (2024). Chronos: Learning the language of time series. Transactions on Machine Learning Research.
• [4] Bellard, F. (2021). NNCP: Lossless data compression with neural networks. https://bellard.org/nncp/.
• [5] Bellard, F. (2023). ts_zip: Text compression using large language models. https://bellard.org/ts_zip/.
• [6] Das, A., Kong, W., Sen, R., and Zhou, Y. (2024). A decoder-only foundation model for time-series forecasting. In International Conference on Machine Learning (ICML). arXiv:2310.10688.
• [7] Delétang, G., Ruoss, A., Duquenne, P.-A., et al. (2024). Language modeling is compression. In International Conference on Learning Representations (ICLR).
• [8] Di, S. and Cappello, F. (2016). Fast error-bounded lossy HPC data compression with SZ. In IEEE International Parallel and Distributed Processing Symposium (IPDPS), pp. 730–739.
• [9] Duda, J. (2009). Asymmetric numeral systems. arXiv:0902.0271.
• [10] U.S. Energy Information Administration (2026). Hourly electric grid monitor, form EIA-930 balancing files. https://www.eia.gov/electricity/gridmonitor/.
• [11] Google Research (2026). TimesFM-3: A zero-shot foundation model for multivariate forecasting. https://huggingface.co/google/timesfm-3.0-pytorch.
• [12] Ibarria, L., Lindstrom, P., Rossignac, J., and Szymczak, A. (2003). Out-of-core compression and decompression of large $n$-dimensional scalar fields. Computer Graphics Forum, 22(3):343–348.
• [13] Kim, T., Kim, J., Tae, Y., Park, C., Choi, J.-H., and Choo, J. (2022). Reversible instance normalization for accurate time-series forecasting against distribution shift. In International Conference on Learning Representations (ICLR).
• [14] Knoll, B. (2024). CMIX: A lossless data compression program. http://www.byronknoll.com/cmix.html.
• [15] Lavin, A. and Ahmad, S. (2015). Evaluating real-time anomaly detection algorithms—the Numenta Anomaly Benchmark. In IEEE International Conference on Machine Learning and Applications (ICMLA).
• [16] Liang, X., Zhao, K., Di, S., et al. (2023). SZ3: A modular framework for composing prediction-based error-bounded lossy compressors. IEEE Transactions on Big Data, 9(2):485–498.
• [17] Lindstrom, P. (2014). Fixed-rate compressed floating-point arrays. IEEE Transactions on Visualization and Computer Graphics, 20(12):2674–2683.
• [18] Lindstrom, P. and Isenburg, M. (2006). Fast and efficient compression of floating-point data. IEEE Transactions on Visualization and Computer Graphics, 12(5):1245–1250.
• [19] Mittu, F., Bu, Y., Gupta, A., et al. (2024). FineZip: Pushing the limits of large language models for practical lossless text compression. arXiv:2409.17141.
• [20] Metropolitan Transportation Authority (2026). MTA subway hourly ridership: Beginning 2025. New York State Open Data. https://data.ny.gov/.
• [21] Pelkonen, T., Franklin, S., Teller, J., et al. (2015). Gorilla: A fast, scalable, in-memory time series database. Proceedings of the VLDB Endowment, 8(12):1816–1827.
• [22] Shannon, C. E. (1948). A mathematical theory of communication. Bell System Technical Journal, 27(3):379–423.
• [23] Tacconelli, R. (2026). Nacrith: Neural lossless compression via ensemble context modeling and high-precision CDF coding. arXiv:2602.19626.
• [24] Blalock, D., Madden, S., and Guttag, J. (2018). Sprintz: Time series compression for the internet of things. Proc. ACM Interact. Mob. Wearable Ubiquitous Technol. (IMWUT), 2(3):93:1–93:23.
• [25] Chiarot, G. and Silvestri, C. (2023). Time series compression survey. ACM Computing Surveys, 55(10):1–32.
• [26] Li, R., Li, Z., Wu, Y., Chen, C., and Zheng, Y. (2023). Elf: Erasing-based lossless floating-point compression. Proceedings of the VLDB Endowment, 16(7):1763–1776.
• [27] Liakos, P., Papakonstantinopoulou, K., and Kotidis, Y. (2022). Chimp: Efficient lossless floating point compression for time series databases. Proceedings of the VLDB Endowment, 15(11):3058–3070.
• [28] Liu, J., Di, S., Zhao, K., et al. (2024). High-performance effective scientific error-bounded lossy compression with auto-tuned multi-component interpolation. Proceedings of the ACM on Management of Data, 2(1):1–27.
• [29] Woo, G., Liu, C., Kumar, A., Xiong, C., Savarese, S., and Sahoo, D. (2024). Unified training of universal time series forecasting transformers. In International Conference on Machine Learning (ICML).
• [30] Zhao, K., Di, S., Dmitriev, M., Tonellot, T.-L. D., Chen, Z., and Cappello, F. (2021). Optimizing error-bounded lossy compression for scientific data by dynamic spline interpolation. In IEEE International Conference on Data Engineering (ICDE), pp. 1643–1654. DOI:10.1109/ICDE51399.2021.00145.
• [31] Zhao, K., Di, S., Lian, X., et al. (2020). SDRBench: Scientific data reduction benchmark for lossy compressors. In IEEE International Conference on Big Data, pp. 2716–2724.