Zero-Shot, Few-Shot & Scaling Laws

Lesson 2 handed you a time-series foundation model: one network, pretrained on a huge pile of unrelated series, that you point at a brand-new dataset and ask for a forecast. This lesson is about how you actually use it — and how to tell whether the forecast it hands back is worth anything.

There’s a spectrum of effort here. At one end you do nothing: feed the model a window of history and read off a forecast, no training of any kind. That’s zero-shot. At the other end you retrain every weight on your target data — full fine-tune. In between sits the interesting middle: few-shot and in-context learning, where the model adapts a little without you touching most of its parameters.

And looming over all of it is the question every quant eventually asks about deep learning: does bigger help? The scaling laws say “yes, predictably” — for most domains. We’ll see why finance is the brutal exception, and why a scaling curve that flattens above the profit threshold is a treadmill you can run on forever and never get anywhere.

Let’s start with doing nothing.

Zero-shot forecasting

The analogy. Picture a seasoned forecaster who has read ten thousand charts across every imaginable market and sensor. You slide a brand-new chart across the desk — one she has never seen, from an industry she doesn’t recognize — and ask, “what comes next?” She doesn’t go study it for a week. She glances at the shape, recognizes the seasonality, the trend, the noise texture, and sketches the continuation cold. That cold read, drawing only on patterns absorbed elsewhere, is zero-shot forecasting. No homework, no fitting — just pattern transfer.

Precise definition. A zero-shot forecast feeds a context window $x_{1:L}$ (the last $L$ observations of a target series) into a frozen pretrained model $f_\theta$ and produces a forecast $\hat{x}_{L+1:L+H}$ over a horizon $H$, with no update to $\theta$. The model has never trained on this series; it generalizes purely from the structure it learned during pretraining. Contrast this with the classical workflow, where you fit a fresh ARIMA or train a fresh LSTM on this exact series before you can forecast it.

How do you know the forecast is any good? You need a benchmark, and “low error” in raw units is meaningless across series with different scales. The standard scale-free yardstick is the MASE.

MASE: the scaled-error benchmark

Mean Absolute Scaled Error compares your forecast’s error to the error of a dead-simple naive baseline — usually the seasonal naive forecast, which just predicts “the same as one season ago.” Formally, for a forecast $\hat{y}_t$ against actuals $y_t$:

$\text{MASE} = \frac{\frac{1}{H}\sum_{t} |y_t - \hat{y}_t|}{\frac{1}{n-m}\sum_{i=m+1}^{n} |y_i - y_{i-m}|}$

The numerator is the MAE of your forecast on the test horizon. The denominator is the MAE of the naive seasonal forecast computed on the training set (predicting each point with the value $m$ steps earlier, where $m$ is the seasonal period). The ratio is unitless, so you can average it across thousands of series of wildly different scales.

The reading is brutally simple:

• MASE < 1 → you beat the naive baseline (good).
• MASE = 1 → you tied the naive baseline (you added nothing).
• MASE > 1 → you are worse than just repeating last season (embarrassing).

Worked example — computing a MASE. Suppose a non-seasonal series ($m=1$, so the naive forecast is “yesterday’s value”). On the training set of 6 points $[10, 12, 11, 14, 13, 15]$, the naive one-step errors are the absolute consecutive differences:

$|12-10|, |11-12|, |14-11|, |13-14|, |15-13| = 2, 1, 3, 1, 2$

Their mean is $(2+1+3+1+2)/5 = 9/5 = 1.8$. That’s the denominator — the naive baseline’s typical error on this series.

Now the model forecasts the next 3 points. Actuals turn out to be $[16, 14, 17]$; the zero-shot forecast was $[15.5, 14.5, 16.0]$. Its absolute errors are $|16-15.5|, |14-14.5|, |17-16.0| = 0.5, 0.5, 1.0$, mean $= 2.0/3 = 0.667$. That’s the numerator.

$\text{MASE}_{\text{zero-shot}} = \frac{0.667}{1.8} = 0.37$

A MASE of 0.37 means the zero-shot forecast’s average error is about a third of the naive baseline’s — a clear, real win. Compare a clumsier forecast $[14, 14, 14]$ (just guessing the last training value): its errors are $|16-14|, |14-14|, |17-14| = 2, 0, 3$, mean $= 5/3 = 1.667$, giving $\text{MASE} = 1.667/1.8 = 0.93$ — barely better than naive. The MASE instantly tells you which forecast actually earned its keep.

When to use it

Reach for zero-shot first whenever you want a fast, fit-free baseline or you simply cannot fit a per-series model — a brand-new asset with three weeks of history, or ten thousand series you can’t babysit individually. It’s also the honest control: before you spend a week fine-tuning, check whether the frozen model already does the job. The catch is that zero-shot can only exploit structure that resembles its pretraining; a series with genuinely novel dynamics (or, as we’ll see, almost no structure at all) gets a mediocre cold read and no amount of “zero” effort fixes it.

The adaptation spectrum

The analogy. Hiring a consultant. Zero-shot is asking her to opine on your problem cold, using only her prior experience. Few-shot is handing her a one-page brief with three worked examples before she answers — she adapts on the spot without you reprogramming her. Full fine-tune is sending her back to school for a semester on your business specifically: maximal customization, maximal cost, and a real risk she forgets everything else (catastrophic forgetting) or just memorizes your three case studies (overfitting).

Precise definitions.

• Zero-shot. No weight updates. Context window in, forecast out.
• Few-shot. A small amount of adaptation: either a handful of in-context examples appended to the prompt/context (no weight change — that’s in-context learning, next section), or a light fine-tune touching only a small subset of parameters (a final layer, a LoRA adapter, a bias-only tune) on a few labeled examples.
• Full fine-tune. Backpropagate into all parameters $\theta$ on your target data, using the pretrained weights only as an initialization.

The trade-off across the spectrum is the heart of the lesson:

Notice the column that matters most for finance: overfitting risk rises as you move right, and financial return series are exactly the low-signal, scarce-sample regime where that risk bites hardest. More adaptation is not automatically better — on noisy data it’s often worse, because you’ve handed a flexible model more rope to fit noise (the data-hunger problem from the deep-learning course).

When to use which

Use zero-shot for cold-start and massive cross-sections; few-shot / light tune when you have a modest amount of clean, relevant target data and want a nudge without a noise-soaking overhaul; full fine-tune only when you genuinely have abundant, aligned target data and a high-SNR task (think microstructure with millions of snapshots, not daily returns). The further right you go, the more you must prove the adaptation helps out of sample, because in-sample loss will always smile back at you.

In-context learning

The analogy. You ask a polyglot friend to translate a sentence into a dialect she’s rusty on. Instead of sending her to language school (fine-tuning), you show her five example translations first. She studies the pattern in the moment and nails the sixth — then forgets it the instant the conversation moves on. The five examples were a tiny, disposable training set that lived entirely in her short-term attention. That’s in-context learning (ICL): the model treats the context as an inference-time training set, adapting its output without any of it sticking to its weights.

Precise statement. Given a context containing $k$ demonstration pairs $(x_1, y_1), \dots, (x_k, y_k)$ followed by a query $x_{\text{query}}$, the model produces $\hat{y}_{\text{query}}$ conditioned on all of them through a single forward pass. The remarkable empirical finding (and an active research area) is that large pretrained sequence models behave as if they ran a learning algorithm over those $k$ pairs internally — yet $\theta$ is untouched. For a time-series foundation model, the “demonstrations” are often just the context window itself: the recent history is the tiny training set the model conditions its continuation on.

Worked intuition — context length on a noisy series. Suppose a series is 90% noise, 10% signal, and you extend the context window from 64 to 512 observations hoping to “show the model more.” On a clean, near-stationary series, more context means more genuine pattern to lock onto — accuracy improves. On a near-efficient return series, the extra 448 observations are overwhelmingly noise: roughly $0.9 \times 448 \approx 403$ of them carry no forecastable structure. You haven’t enriched the tiny training set with signal; you’ve diluted it with distractors, and the model can spuriously “learn” a pattern from noise that won’t recur. Longer context helps only in proportion to the signal density of what you add.

When to use it

In-context / few-shot prompting shines when you have a few clean, representative examples and want adaptation with zero training infrastructure — no optimizer, no checkpoint, no catastrophic-forgetting risk, and instant iteration. It’s the natural default for cold-start and rapid prototyping. It fades exactly where signal density is low: piling more context onto a noisy return series feeds the model more noise, not more edge.

Scaling laws

The analogy. Polishing a lens. The first hours of polishing sharpen the image dramatically. Keep going and each additional hour helps less — and no amount of polishing beats the diffraction limit set by physics: there’s a floor of blur you simply cannot grind away. Neural scaling is the same. Pour in more parameters, data, and compute and the loss keeps dropping along a smooth power-law curve — but with diminishing returns, and it bottoms out at an irreducible floor $L_\infty$ set by how much signal the problem contains. You can polish forever; you cannot beat the diffraction limit.

Precise form. A common parameterization of the scaling law in model size $N$ (holding data/compute ample) is:

$L(N) = L_\infty + \left(\frac{N_c}{N}\right)^{\alpha}$

where $L(N)$ is the test loss at $N$ parameters, $L_\infty$ is the irreducible loss (the entropy floor — the part no model can ever remove), $N_c$ is a problem-specific scale constant, and $\alpha > 0$ is the scaling exponent (the steepness of the diminishing-returns curve). Kaplan et al. (2020) found such power laws spanning many orders of magnitude in language; Hoffmann et al. (2022, “Chinchilla”) refined the compute-optimal balance, showing many models were oversized and undertrained — you should scale data and parameters together.

Worked example — diminishing returns. Take $L_\infty = 0.5$, $N_c = 10^6$, $\alpha = 0.5$ (so the reducible term is $\sqrt{N_c/N}$):

Going from $10^4$ to $10^6$ parameters (×100) slashed loss by 9.0. The next ×100 (to $10^8$) bought only 0.9. The next ×100 bought 0.09. Each 100× scale-up delivers a tenth of the previous improvement, and the curve is visibly crawling toward $L_\infty = 0.5$. That asymptote is the whole story for finance.

Do scaling laws hold on market data?

Here’s the killer question. In language and vision, $L_\infty$ is small — there is enormous learnable structure, so scaling pays off for a long, long way before the floor bites. Markets are different. A near-efficient market has, almost by construction, a huge irreducible floor: next-period returns are close to a martingale, so the entropy of the target is nearly maximal and the forecastable component is tiny. The scaling law still holds — loss still falls as a power law — but it flattens out at $L_\infty$ long before that floor is low enough to trade profitably.

The noise-floor argument, side by side. Imagine the same scaling law $L(N) = L_\infty + (N_c/N)^\alpha$ in two domains:

On returns, you can 100× your parameters and your data, ride the power-law curve down exactly as the math promises, and still land at a loss that’s above the threshold where a strategy makes money after costs. The model gets “better” in loss while remaining useless in P&L, because the floor it’s approaching is set by the market’s near-efficiency, not by your compute budget.

When scaling is worth the compute

Scale up when the floor is low and you’re above it — i.e. there is abundant learnable structure and your current loss is far from $L_\infty$, so the next doubling still buys real accuracy. That describes high-SNR, data-rich tasks (microstructure nowcasting, cross-sectional structure with millions of samples) far better than it describes a single liquid asset’s daily returns. The honest test before spending the GPU budget: estimate where $L_\infty$ sits relative to your profit threshold. If you can’t show the floor is below the threshold, scaling is the treadmill — and a smaller, cheaper model gets you the same nowhere.

When zero-shot / few-shot is worth trying

Pulling the spectrum and the scaling argument together gives a clean decision rule. Zero-shot and few-shot earn their keep where data is the binding constraint and the floor is reachable — and disappoint exactly where the market is most efficient.

Reach for zero-shot / few-shot when:

Do NOT reach for it when: you’re trying to squeeze alpha from one liquid, heavily-arbitraged, low-SNR return series. That’s the worst case on every axis — the irreducible floor is enormous (near-efficiency), any structure has been arbitraged away by armies of competitors, and a frozen model trained on unrelated series has no special claim on the residual. Here the foundation model is, at best, another mediocre forecaster of an unforecastable thing, and the scaling laws promise it won’t get better with size.

The trade-off in one line

Zero-shot/few-shot trades transfer for fitting: you give up bespoke per-series training in exchange for instant, fit-free forecasts powered by pretraining. That trade is a steal when you have no data to fit (cold-start, illiquid, huge breadth) and a sucker’s bet when the real constraint isn’t data but the market’s own efficiency. Match the tool to the binding constraint — data scarcity, yes; entropy floor, never.

Recap