Mistral Timestral lokaal draaien voor tijdreeksvoorspellingen

Wat als je aandelenkoersen kon voorspellen met een klein AI-model dat lokaal draait, in milliseconden voorspellingen teruggeeft en geen extra training nodig heeft?

Voorspellen van tijdreeksen betekent meestal statistische methoden zoals ARIMA, machinelearning-pijplijnen of modellen die op een specifieke dataset zijn getraind. Timestral, een familie van open-weight voorspellingsmodellen die Mistral AI op 15 oktober 2026 uitbracht, pakt het anders aan. Het voorspelt toekomstige waarden op basis van historische data zonder fine-tuning, en volgens Mistral staat het grootste model op de eerste plaats onder vooraf getrainde zero-shot-modellen op drie publieke benchmarks.

Ondanks hun kleine formaat leveren de modellen concurrerende nauwkeurigheid op meerdere forecasting-benchmarks en zijn ze toepasbaar op alles van financiële markten tot energieverbruik en retailvraag.

In deze tutorial kijken we wat Timestral is en hoe het werkt, zetten we het lokaal op met Python en uv, en testen we het op echte Apple (AAPL)-aandelendata. We genereren rollende eendaagse voorspellingen, vergelijken die met de daadwerkelijke slotkoersen en een naïeve baseline, en zetten de voorspellingen om in simpele Buy-, Sell- of Hold-signalen. Bekijk ook onze tutorials over time series forecasting met TimeGPT en ARIMA voor tijdreeksvoorspellingen.

Wat is Mistral Timestral?

Timestral is een open-weight foundation-modelfamilie voor tijdreeksen van Mistral AI voor snelle, algemene forecasting. Een foundation-model voor tijdreeksen wordt één keer vooraf getraind op een grote, gevarieerde collectie reeksen, zodat het data kan voorspellen die het nog niet eerder heeft gezien.

In tegenstelling tot traditionele voorspellingsmodellen die training op een specifieke dataset nodig hebben, ondersteunt Timestral zero-shot forecasting. Het voorspelt toekomstige waarden direct uit historische data, zonder extra training of fine-tuning.

Timestral is een causale, patch-based transformer die voornamelijk op synthetische data is getraind, gevolgd door een tweede trainingsfase op een mix van echte en synthetische data. Het kan omgaan met aandelenkoersen, energievraag, verkoopcijfers en sensormetingen. Mistral beschrijft de architectuur en training in het technische rapport.

Mistral bracht vier groottes uit, elk met een andere afweging tussen modelgrootte, snelheid en nauwkeurigheid:

Volgens Mistrals gepubliceerde benchmarks staat Timestral-209M op de eerste plaats onder vooraf getrainde en zero-shot-modellen op GIFT-Eval, TIME en fev-bench. Het verslaat grotere modellen zoals TimesFM-3 en Falcon-2.0 in de gerapporteerde vergelijkingen. Dit zijn Mistrals eigen resultaten, ingediend bij de GIFT-Eval- en TIME-leaderboards, dus check de leaderboards voor onafhankelijke bevestiging.

Snelheid is een ander voordeel. Op een standaard server-CPU met 8 threads rapporteert Mistral dat Timestral-209M één dag vooruit voorspelt op basis van drie weken 15-minuten-historie in 113 milliseconden, en het 5M-model doet er 17 milliseconden over. Er is geen GPU vereist.

Timestral ondersteunt deze forecasting-features:

• Lange historische context: Accepteert tot 32.768 historische tijdstappen.
• Multivariate forecasting: Voorspelt meerdere gerelateerde tijdreeksen tegelijk om de voorspellingen te verbeteren.
• Probabilistische voorspellingen: Geeft 21 kwantielen terug om de onzekerheid van de voorspelling te schatten, in plaats van één waarde.
• Covariaten: Accepteert alleen-verleden en bekend-toekomstige variabelen, numeriek of categorisch, die de voorspelling kunnen beïnvloeden.
• Lokale inferentie: Draait op CPU's en GPU's zonder betaalde API. De code is vrijgegeven onder Apache 2.0 en de gewichten onder een aangepaste MIT-licentie.

Voor deze tutorial gebruiken we Timestral-209M, het grootste en volgens Mistrals gepubliceerde benchmarks nauwkeurigste model in de familie. We draaien het lokaal op een NVIDIA RTX 4070 GPU om aandelenkoersen te voorspellen en de prestaties op echte marktdata te evalueren.

Timestral instellen op Linux

Timestral heeft Python 3.10 of hoger en PyTorch 2.4 of hoger nodig. We gebruiken Python 3.12, PyTorch 2.7.0 en uv om een lichte ontwikkelomgeving op een Linux-machine te maken. Timestral ondersteunt ook CPU-inferentie, dus een GPU is optioneel.

Controleer eerst of je NVIDIA GPU wordt gedetecteerd en of de drivers werken:

nvidia-smiMogelijk gemaakt door

Dit commando toont je GPU-informatie, driverversie en CUDA-compatibiliteit. Als je GPU in de output verschijnt, kun je verdergaan.

Installeer daarna uv, een snelle Python-package- en omgevingsmanager:

curl -LsSf https://astral.sh/uv/install.sh | shMogelijk gemaakt door

Start je terminal opnieuw op na het installeren van uv zodat het commando beschikbaar wordt in je shell.

Maak nu een projectmap en een Python 3.12-virtuele omgeving:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateMogelijk gemaakt door

Installeer vervolgens PyTorch 2.7.0 met CUDA 12.6-ondersteuning:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Mogelijk gemaakt door

Tijdens het testen gaf de CUDA 12.8-build een drivercompatibiliteitsfout op onze RTX 4070. Overschakelen naar PyTorch 2.7.0 met CUDA 12.6 loste het op zonder driverupdate. Afhankelijk van je GPU en NVIDIA-driver heb je mogelijk een andere CUDA-build nodig.

Als je geen GPU hebt, installeer dan in plaats daarvan de CPU-build door de index-URL te vervangen door https://download.pytorch.org/whl/cpu. De code later in deze tutorial valt automatisch terug op de CPU.

Installeer nu Timestral rechtstreeks vanuit de officiële GitHub-repository:

uv pip install git+https://github.com/mistralai/timestral.gitMogelijk gemaakt door

Installeer de overige libraries voor het downloaden van beursdata, het verwerken van voorspellingen, het maken van visualisaties en het draaien van notebooks:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmMogelijk gemaakt door

We gebruiken yfinance om historische aandelenkoersen op te halen, pandas en NumPy voor dataverwerking, en Matplotlib voor het plotten van daadwerkelijke versus voorspelde koersen. We beperken ook de pandas-versie tot het bereik dat we tijdens het testen gebruikten om compatibiliteitsgerelateerde waarschuwingen te voorkomen.

Controleer voor je verdergaat of PyTorch toegang heeft tot je GPU:

python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'No CUDA GPU available')"Mogelijk gemaakt door

Onze output:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Mogelijk gemaakt door

De waarde True bevestigt dat CUDA beschikbaar is voor PyTorch, en de laatste regel identificeert de GPU. We zijn nu klaar om met Timestral te experimenteren.

In plaats van losse Pythonscripts gebruiken we JupyterLab zodat we code stap voor stap kunnen draaien, voorspelde waarden kunnen inspecteren en voorspellingen kunnen vergelijken met echte marktdata. Start JupyterLab vanuit je projectmap:

python -m jupyter labMogelijk gemaakt door

Open de URL die in je terminal wordt weergegeven, meestal http://localhost:8888/lab, en maak een nieuw Python-notebook met de omgeving die we zojuist hebben geconfigureerd. We gebruiken dit notebook om Timestral te laden, voorspellingen te genereren en te evalueren hoe goed het model presteert.

Voorspel Apple-aandelenkoersen met Timestral

In plaats van synthetische data te genereren gebruiken we echte historische Apple-aandelenkoersen en meten we hoe nauwkeurig Timestral de slotkoers van de volgende handelsdag voorspelt.

Om het experiment realistischer te maken, gebruiken we rollende eendaagse voorspellingen. Voor elke handelsdag in de testperiode krijgt Timestral de vorige 500 slotkoersen en voorspelt het alleen de slotkoers van de volgende dag.

We vergelijken ook twee methoden:

• Voorspellen van ruwe prijs: Voorspel de volgende slotkoers direct.
• Voorspellen van log-return: Voorspel de volgende logaritmische prijsverandering en zet die terug om naar een slotkoers.

1. Download historische aandelenkoersen

Start een notebook en importeer de benodigde libraries. We zetten ook het symbool, het aantal testdagen, het contextvenster en de modelnaam.

import numpy as np
import pandas as pd
import torch
import yfinance as yf
import matplotlib.pyplot as plt
from tqdm.auto import tqdm
from IPython.display import display
from timestral import TimestralForecaster

TICKER = "AAPL"
DAYS = 60
WINDOW = 500
MODEL = "mistralai/Timestral-209M"Mogelijk gemaakt door

Download nu vijf jaar aan dagelijkse Apple-aandelendata. Door auto_adjust=True in te stellen, krijg je slotkoersen gecorrigeerd voor splitsingen en dividenden.

data = yf.download(
    TICKER,
    period="5y",
    interval="1d",
    auto_adjust=True,
    multi_level_index=False,
    progress=False,
)

close = data["Close"].dropna().astype(float)

assert len(close) >= WINDOW + DAYS
assert (close > 0).all()
display(data.tail())Mogelijk gemaakt door

We gebruiken de laatste 60 handelsdagen voor testen en de voorafgaande 500 observaties als context voor elke voorspelling.

2. Laad Timestral op je GPU

Laad het 209M-model op de GPU, met een fallback naar de CPU als CUDA niet beschikbaar is. De 837 MB aan gewichten worden de eerste keer gedownload van Hugging Face wanneer je deze cel draait.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = TimestralForecaster.from_pretrained(
    MODEL,
    device=device,
)

print(f"Loaded {MODEL} on {device}")Mogelijk gemaakt door

Ons model werd succesvol geladen op de RTX 4070:

Loaded mistralai/Timestral-209M on cudaMogelijk gemaakt door

3. Genereer rollende eendaagse voorspellingen

Nu genereren we twee voorspellingen voor elke handelsdag: één op basis van historische slotkoersen en één op basis van log-returns. Een log-return is de dagelijkse verandering in de logaritme van de prijs, en we zetten elke voorspelde return terug om naar een prijs met de vorige slotkoers.

actual = []
price_predictions = []
return_predictions = []
previous_prices = []
lower_bounds = []
upper_bounds = []
dates = []

for i in tqdm(range(DAYS), desc="Forecasting"):
    pos = len(close) - DAYS + i
    history = close.iloc[pos - WINDOW:pos].to_numpy(dtype=np.float32)
    previous = float(history[-1])

    with torch.inference_mode():
        # Forecast raw prices
        price_fc = model.forecast(
            history,
            prediction_length=1,
        )
        price_pred = float(price_fc.median.squeeze())

        # Forecast log returns
        returns = np.diff(np.log(history))
        return_fc = model.forecast(
            returns.astype(np.float32),
            prediction_length=1,
        )
        return_pred = previous * np.exp(
            float(return_fc.median.squeeze())
        )

    actual.append(float(close.iloc[pos]))
    previous_prices.append(previous)
    price_predictions.append(price_pred)
    return_predictions.append(return_pred)
    lower_bounds.append(float(price_fc.quantile(0.1).squeeze()))
    upper_bounds.append(float(price_fc.quantile(0.9).squeeze()))
    dates.append(close.index[pos])

actual = np.array(actual)
previous_prices = np.array(previous_prices)
price_predictions = np.array(price_predictions)
return_predictions = np.array(return_predictions)
lower_bounds = np.array(lower_bounds)
upper_bounds = np.array(upper_bounds)

results = pd.DataFrame({
    "Previous Close": previous_prices,
    "Actual": actual,
    "Raw Prediction": price_predictions,
    "Return Prediction": return_predictions,
    "Lower 10%": lower_bounds,
    "Upper 90%": upper_bounds,
}, index=pd.DatetimeIndex(dates, name="Date"))

display(results.tail())Mogelijk gemaakt door

Het model genereert 60 rollende eendaagse voorspellingen, telkens met de vorige 500 slotkoersen. Elke voorspelling gebruikt alleen data die vóór de doel-dag beschikbaar was, zodat toekomstige prijzen niet in de invoer van het model kunnen lekken.

4. Evalueer de voorspellingsnauwkeurigheid

We meten mean absolute error (MAE), root mean squared error (RMSE), mean absolute percentage error (MAPE) en richtingsnauwkeurigheid. We vergelijken Timestral ook met een naïeve baseline die aanneemt dat de slotkoers van morgen gelijk is aan die van vandaag.

actual = results["Actual"].to_numpy()
previous = results["Previous Close"].to_numpy()
raw = results["Raw Prediction"].to_numpy()
ret = results["Return Prediction"].to_numpy()

def evaluate(prediction, baseline=False):
    metrics = {
        "MAE ($)": np.mean(np.abs(actual - prediction)),
        "RMSE ($)": np.sqrt(np.mean((actual - prediction) ** 2)),
        "MAPE (%)": np.mean(np.abs((actual - prediction) / actual)) * 100,
    }
    metrics["Direction (%)"] = (
        np.nan if baseline
        else np.mean(np.sign(actual - previous) == np.sign(prediction - previous)) * 100
    )
    return metrics

metrics = pd.DataFrame({
    "Baseline": evaluate(previous, baseline=True),
    "Raw Prices": evaluate(raw),
    "Log Returns": evaluate(ret),
}).T

coverage = (
    (actual >= results["Lower 10%"].to_numpy())
    & (actual <= results["Upper 90%"].to_numpy())
).mean() * 100

display(metrics.round(2))
print(f"Raw-price 10-90% interval coverage: {coverage:.1f}%")Mogelijk gemaakt door

Onze resultaten laten zien dat Timestral iets beter presteert bij het voorspellen van log-returns dan bij ruwe aandelenprijzen. 

De log-return-benadering haalde de laagste MAE ($3,05), RMSE ($3,84) en MAPE (0,93%), en presteerde nipt beter dan onze baseline. 

Belangrijker nog: de richtingsnauwkeurigheid steeg van 41,67% bij ruwe prijzen naar 55% bij log-returns, wat wijst op betere prestaties in het voorspellen of aandelenkoersen stijgen of dalen. 

Het ruwe-prijsmodel bereikte ook 81,7% intervaldekking, dicht bij de verwachte 80%, wat duidt op redelijk gekalibreerde onzekerheidsschattingen. Al met al genereerde Timestral vrij nauwkeurige prijsvoorspellingen, maar de verbetering ten opzichte van de eenvoudige baseline was minimaal, en verder testen is nodig om te bepalen of de voorspellingen betrouwbaar handelsbeslissingen kunnen ondersteunen.

5. Visualiseer Timestral-voorspellingen

Laten we de daadwerkelijke slotkoersen uitzetten tegen beide voorspellingsmethoden met Matplotlib.

fig, axes = plt.subplots(
    2, 1,
    figsize=(14, 9),
    gridspec_kw={"height_ratios": [2, 1]},
    sharex=True,
)

# Actual vs predicted prices
axes[0].plot(
    dates, actual,
    label="Actual Price",
    color="green",
    linewidth=2.5,
)
axes[0].plot(
    dates, price_predictions,
    label="Timestral Raw Price",
    color="orange",
    linestyle="--",
)
axes[0].plot(
    dates, return_predictions,
    label="Timestral Log Returns",
    color="royalblue",
    linestyle="--",
)
axes[0].fill_between(
    dates,
    lower_bounds,
    upper_bounds,
    color="orange",
    alpha=0.12,
    label="10-90% Forecast Range",
)
axes[0].set_title(f"Timestral-209M | {TICKER} Rolling One-Day Forecast")
axes[0].set_ylabel("Adjusted Close (USD)")
axes[0].legend()
axes[0].grid(alpha=0.2)

# Prediction errors
axes[1].plot(
    dates,
    price_predictions - actual,
    label="Raw Price Error",
    color="orange",
)
axes[1].plot(
    dates,
    return_predictions - actual,
    label="Log Return Error",
    color="royalblue",
)
axes[1].axhline(0, color="black", linestyle=":")
axes[1].set_ylabel("Error ($)")
axes[1].set_xlabel("Date")
axes[1].legend()
axes[1].grid(alpha=0.2)

fig.autofmt_xdate()
plt.tight_layout()
fig.savefig("aapl_improved.png", dpi=180, bbox_inches="tight")
plt.show()Mogelijk gemaakt door

De grafiek laat zien hoe dicht Timestral de daadwerkelijke prijzen van Apple volgt over de 60 handelsdagen. Beide benaderingen vangen de opwaartse trend, en het oranje gearceerde gebied is het 10–90%-voorspellingsinterval van het ruwe-prijsmodel. Het onderste paneel toont de dagelijkse voorspellingsfouten.

De meeste fouten blijven binnen ongeveer $5, met een paar grotere missers van $9 tot $11 bij plotselinge koersbewegingen. De twee methoden leveren bijna identieke voorspellingen op, met log-returns licht in het voordeel. Beide voorspellingslijnen lopen de daadwerkelijke prijs ook ongeveer één dag achter, wat past bij het kleine verschil met de naïeve baseline.

6. Genereer Buy-, Hold- en Sell-signalen

Laten we de ruwe-prijsvoorspellingen nu omzetten in experimentele Buy-, Hold- en Sell-signalen. We gebruiken een drempel van 1% op de voorspelde prijsverandering:

• BUY: Voorspelde prijsstijging groter dan 1%.
• SELL: Voorspelde prijsdaling groter dan 1%.
• HOLD: Voorspelde prijsbeweging tussen -1% en +1%.

We kunnen deze regels implementeren met NumPy:

THRESHOLD = 1.0

change_pct = (
    price_predictions / previous_prices - 1
) * 100

signals = np.where(
    change_pct > THRESHOLD,
    "BUY",
    np.where(change_pct < -THRESHOLD, "SELL", "HOLD"),
)

results["Expected Change (%)"] = change_pct
results["Signal"] = signals

display(results.tail(10).round(2))
display(results["Signal"].value_counts())

results.to_csv("aapl_signals.csv")Mogelijk gemaakt door

Alle 60 handelsdagen leverden HOLD-signalen op, zonder BUY- of SELL-aanbevelingen. In de laatste 10 rijen overschrijdt de verwachte verandering nergens 0,15% in welke richting dan ook, ver onder onze drempel van 1%.

Deze signalen komen uit de ruwe-prijsvoorspellingen, die de zwakkere richtingsnauwkeurigheid hadden (41,67%). Wil je signalen uit de log-return-voorspellingen zien, vervang dan price_predictions door return_predictions in de change_pct-berekening. Een lagere drempel levert meer BUY- en SELL-signalen op, maar maakt ze ook gevoeliger voor voorspellingsfouten en marktgeruis.

Deze signaalregels zijn bedoeld om mee te experimenteren, niet voor live trading, en niets in deze tutorial is financieel advies. Meer backtesting, drempelafstemming en analyse van transactiekosten zijn nodig om te bepalen of ze een winstgevende strategie kunnen ondersteunen.

Tot slot

Al met al ben ik erg onder de indruk van Timestral. 

De hele setup was eenvoudig, inferentie was snel, en ik kon alles lokaal draaien op mijn RTX 4070 zonder afhankelijk te zijn van externe API's. 

Wat het extra aantrekkelijk maakt, is dat deze lichte modellen ook op CPU's kunnen draaien, waardoor ze toegankelijk zijn zonder dure hardware.

Wat betreft voorspellingsnauwkeurigheid waren onze resultaten gemengd. 

Timestral volgde aandelenkoersen redelijk goed, maar presteerde nauwelijks beter dan een simpele baseline.

Ik ben geen expert in financiële forecasting of trading, dus er valt waarschijnlijk meer te winnen met datapreparatie, voorspellingsstrategieën en parameterafstemming om betere resultaten te halen.

Ik heb eerder gebruikgemaakt van gehoste voorspellingsdiensten zoals TimeGPT, maar Timestral heeft lokaal voorspellen een stuk aantrekkelijker gemaakt. Sinds de release ben ik meer van mijn forecasting-workloads naar lokale modellen gaan verplaatsen omdat ze snel en lichtgewicht zijn, en vrij van API-calls en gebruiksgebonden kosten.

Voor mij is Timestral's grootste kracht niet alleen de nauwkeurigheid, maar vooral hoe makkelijk en goedkoop het voorspellen wordt.

Je kunt een capabel tijdreeksmodel op je eigen hardware draaien, vrij experimenteren en het in applicaties bouwen zonder afhankelijk te zijn van externe services. Zelfs als onze aandelenschattingen niet indrukwekkend waren, vind ik Timestral een uitstekende optie voor iedereen die lokale forecasting-toepassingen bouwt.

Wil je meer leren over forecasting, bekijk dan onze cursus Time Series Analysis in Python. Voor finance-specifieke modellering kun je Machine Learning for Finance in Python proberen.