Mistral Timestral lokal ausführen für Zeitreihenprognosen

Was wäre, wenn du Aktienkurse mit einem kleinen KI-Modell vorhersagen könntest, das lokal läuft, Vorhersagen in Millisekunden liefert und keine zusätzliche Trainingsphase braucht?

Zeitreihenprognosen bedeuten meist statistische Methoden wie ARIMA, Machine-Learning-Pipelines oder eigens trainierte Modelle. Timestral, eine Familie von Open-Weight-Prognosemodellen, die Mistral AI am 15. Oktober 2026 veröffentlicht hat, geht einen anderen Weg. Es sagt zukünftige Werte allein aus historischen Daten voraus – ganz ohne Fine-Tuning – und laut Mistral belegt das größte Modell auf drei öffentlichen Benchmarks den Spitzenplatz unter vortrainierten Zero-Shot-Modellen.

Trotz der kompakten Größe liefern die Modelle auf mehreren Forecasting-Benchmarks wettbewerbsfähige Genauigkeit und lassen sich von Finanzmärkten bis hin zu Energieverbrauch und Einzelhandelsnachfrage einsetzen.

In diesem Tutorial schauen wir uns an, was Timestral ist und wie es funktioniert, richten es lokal mit Python und uv ein und testen es an echten Apple-(AAPL)-Kursdaten. Wir erzeugen rollierende Eintagesprognosen, vergleichen sie mit den tatsächlichen Schlusskursen und einer naiven Basislinie und leiten daraus einfache Buy-, Sell- oder Hold-Signale ab. Sieh dir auch unsere Tutorials zu Zeitreihenprognosen mit TimeGPT und ARIMA für Zeitreihen an.

Was ist Mistral Timestral?

Timestral ist eine Open-Weight-Grundlagenmodellfamilie von Mistral AI für schnelle, universelle Zeitreihenprognosen. Ein Zeitreihen-Grundlagenmodell wird einmalig auf einer großen, vielfältigen Sammlung von Reihen vortrainiert, sodass es auch unbekannte Daten vorhersagen kann.

Im Gegensatz zu klassischen Prognosemodellen, die auf einem spezifischen Datensatz trainiert werden müssen, unterstützt Timestral Zero-Shot-Forecasting. Es prognostiziert zukünftige Werte direkt aus historischen Daten – ohne zusätzliches Training oder Fine-Tuning.

Timestral ist ein kausaler, patch-basierter Transformer, der überwiegend auf synthetischen Daten trainiert wurde, gefolgt von einer zweiten Trainingsphase mit einem Mix aus realen und synthetischen Daten. Es verarbeitet Aktienkurse, Energienachfrage, Verkäufe und Sensormessungen. Mistral beschreibt Architektur und Training im Technical Report.

Mistral hat vier Größen veröffentlicht, jeweils mit unterschiedlichem Trade-off zwischen Modellgröße, Geschwindigkeit und Genauigkeit:

Laut den veröffentlichten Benchmarks von Mistral liegt Timestral-209M unter vortrainierten Zero-Shot-Modellen auf GIFT-Eval, TIME und fev-bench auf Platz eins. Es schlägt in den Vergleichen größere Modelle wie TimesFM-3 und Falcon-2.0. Das sind Mistrals eigene Ergebnisse, eingereicht für die GIFT-Eval- und TIME-Leaderboards – prüfe die Leaderboards für unabhängige Bestätigungen.

Ein weiterer Vorteil ist die Geschwindigkeit. Auf einer Standard-Server-CPU mit 8 Threads meldet Mistral, dass Timestral-209M einen Tag im Voraus aus drei Wochen 15-Minuten-Historie in 113 Millisekunden prognostiziert; das 5M-Modell benötigt 17 Millisekunden. Eine GPU ist nicht erforderlich.

Timestral unterstützt folgende Forecasting-Funktionen:

• Langer historischer Kontext: Verarbeitet bis zu 32.768 historische Zeitschritte.
• Multivariate Prognosen: Sagt mehrere zusammenhängende Zeitreihen gemeinsam voraus, um die Genauigkeit zu verbessern.
• Probabilistische Vorhersagen: Gibt 21 Quantile zurück, um Unsicherheit abzuschätzen, statt nur eines Punktwerts.
• Kovariaten: Akzeptiert vergangene und bekannte zukünftige Variablen, numerisch oder kategorial, die den Forecast beeinflussen können.
• Lokale Inferenz: Läuft auf CPUs und GPUs ohne kostenpflichtige API. Der Code steht unter Apache 2.0, die Gewichte unter einer modifizierten MIT-Lizenz.

Für dieses Tutorial verwenden wir Timestral-209M, laut Mistrals Benchmarks das größte und genaueste Modell der Familie. Wir lassen es lokal auf einer NVIDIA RTX 4070 GPU laufen, um Aktienkurse zu prognostizieren und die Performance auf realen Marktdaten zu bewerten.

Timestral unter Linux einrichten

Timestral benötigt Python 3.10 oder höher und PyTorch 2.4 oder höher. Wir verwenden Python 3.12, PyTorch 2.7.0 und uv, um auf einer Linux-Maschine eine schlanke Entwicklungsumgebung aufzusetzen. Timestral unterstützt auch CPU-Inferenz, eine GPU ist also optional.

Prüfe zuerst, ob deine NVIDIA-GPU erkannt wird und die Treiber funktionieren:

nvidia-smiBereitgestellt von

Dieser Befehl zeigt Informationen zur GPU, zur Treiberversion und zur CUDA-Kompatibilität. Wenn deine GPU im Output erscheint, kannst du fortfahren.

Installiere als Nächstes uv, einen schnellen Paket- und Umgebungsmanager für Python:

curl -LsSf https://astral.sh/uv/install.sh | shBereitgestellt von

Starte nach der Installation von uv dein Terminal neu, damit der Befehl in deiner Shell verfügbar ist.

Lege nun ein Projektverzeichnis und eine virtuelle Umgebung mit Python 3.12 an:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateBereitgestellt von

Installiere anschließend PyTorch 2.7.0 mit CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Bereitgestellt von

In unseren Tests verursachte der CUDA-12.8-Build auf der RTX 4070 einen Treiberkompatibilitätsfehler. Der Wechsel zu PyTorch 2.7.0 mit CUDA 12.6 behob das Problem ohne Treiberupdate. Abhängig von GPU und NVIDIA-Treiber brauchst du ggf. einen anderen CUDA-Build.

Ohne GPU installierst du stattdessen den CPU-Build, indem du die Index-URL durch https://download.pytorch.org/whl/cpu ersetzt. Der Code weiter unten fällt automatisch auf die CPU zurück.

Installiere Timestral nun direkt aus dem offiziellen GitHub-Repository:

uv pip install git+https://github.com/mistralai/timestral.gitBereitgestellt von

Installiere die restlichen Bibliotheken zum Herunterladen von Marktdaten, zur Verarbeitung der Vorhersagen, zur Visualisierung und für Notebooks:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmBereitgestellt von

Wir nutzen yfinance für historische Kurse, pandas und NumPy für die Datenverarbeitung und Matplotlib für die Visualisierung von Ist- versus Prognosewerten. Außerdem begrenzen wir die pandas-Version auf den in unseren Tests verwendeten Bereich, um kompatibilitätsbedingte Warnungen zu vermeiden.

Bevor es weitergeht, prüfe, ob PyTorch auf deine GPU zugreifen kann:

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')"Bereitgestellt von

Unsere Ausgabe:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Bereitgestellt von

Der Wert True bestätigt, dass CUDA für PyTorch verfügbar ist, und die letzte Zeile identifiziert die GPU. Damit können wir mit Timestral experimentieren.

Statt einzelner Python-Skripte verwenden wir JupyterLab. So können wir Code schrittweise ausführen, Forecasts inspizieren und Vorhersagen mit echten Marktdaten vergleichen. Starte JupyterLab aus deinem Projektverzeichnis:

python -m jupyter labBereitgestellt von

Öffne die im Terminal ausgegebene URL, meist http://localhost:8888/lab, und erstelle ein neues Python-Notebook mit der soeben eingerichteten Umgebung. In diesem Notebook laden wir Timestral, erzeugen Vorhersagen und bewerten die Modellleistung.

Apple-Aktienkurse mit Timestral prognostizieren

Statt synthetischer Daten verwenden wir echte historische Apple-Kurse und messen, wie gut Timestral den Schlusskurs des nächsten Handelstags trifft.

Um das Experiment realistischer zu machen, verwenden wir rollierende Eintagesprognosen. Für jeden Handelstag im Testzeitraum erhält Timestral die vorangegangenen 500 Schlusskurse und sagt nur den Schlusskurs des Folgetags voraus.

Wir vergleichen zudem zwei Ansätze:

• Rohpreis-Prognose: Direkte Vorhersage des nächsten Schlusskurses.
• Log-Return-Prognose: Vorhersage der nächsten logarithmischen Preisänderung und Rückrechnung auf einen Schlusskurs.

1. Historische Kurse herunterladen

Starte ein Notebook und importiere die benötigten Bibliotheken. Wir setzen außerdem Ticker, Anzahl Testtage, Kontextfenster und Modellnamen.

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"Bereitgestellt von

Lade nun fünf Jahre täglicher Apple-Daten. Mit auto_adjust=True erhältst du um Splits und Dividenden bereinigte Schlusskurse.

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())Bereitgestellt von

Wir verwenden die letzten 60 Handelstage zum Testen und jeweils die vorherigen 500 Beobachtungen als Kontext für jede Vorhersage.

2. Timestral auf der GPU laden

Lade das 209M-Modell auf die GPU, mit CPU-Fallback, falls CUDA nicht verfügbar ist. Die 837 MB an Gewichten werden beim ersten Lauf aus Hugging Face heruntergeladen.

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

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

print(f"Loaded {MODEL} on {device}")Bereitgestellt von

Bei uns wurde das Modell erfolgreich auf der RTX 4070 geladen:

Loaded mistralai/Timestral-209M on cudaBereitgestellt von

3. Rollierende Eintagesprognosen erzeugen

Jetzt erzeugen wir pro Handelstag zwei Vorhersagen: eine aus historischen Schlusskursen und eine aus Log-Returns. Ein Log-Return ist die tägliche Änderung des Logarithmus des Preises; die vorhergesagte Rendite rechnen wir mit dem vorherigen Schlusskurs zurück in einen Preis.

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())Bereitgestellt von

Das Modell erzeugt 60 rollierende Eintagesprognosen und verwendet dafür jeweils die vorherigen 500 Schlusskurse. Jede Prognose nutzt nur Daten, die vor dem Zieltag verfügbar waren – ein Leakage zukünftiger Preise in die Eingaben ist somit ausgeschlossen.

4. Prognosegenauigkeit bewerten

Wir messen Mean Absolute Error (MAE), Root Mean Squared Error (RMSE), Mean Absolute Percentage Error (MAPE) und die Richtungstrefferquote. Außerdem vergleichen wir Timestral mit einer naiven Basislinie, die annimmt, dass der morgige Schlusskurs dem heutigen entspricht.

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}%")Bereitgestellt von

Unsere Ergebnisse zeigen, dass Timestral bei der Vorhersage von Log-Returns etwas besser abschneidet als bei Rohpreisen. 

Der Log-Return-Ansatz erzielte den niedrigsten MAE (3,05 $), RMSE (3,84 $) und MAPE (0,93 %) und lag damit knapp vor unserer Basislinie. 

Wichtiger noch: Die Richtungstrefferquote stieg von 41,67 % bei Rohpreisen auf 55 % mit Log-Returns – ein Hinweis darauf, dass die Richtung (steigend oder fallend) besser getroffen wurde. 

Das Rohpreis-Modell erreichte zudem eine Intervallabdeckung von 81,7 % für das 10–90-%-Band – nahe am erwarteten Wert von 80 % –, was auf vernünftig kalibrierte Unsicherheitsabschätzungen hindeutet. Insgesamt lieferte Timestral recht präzise Preisprognosen, der Vorsprung gegenüber der einfachen Basislinie war jedoch minimal. Weitere Tests sind nötig, um zu klären, ob sich die Vorhersagen verlässlich für Handelsentscheidungen eignen.

5. Timestral-Vorhersagen visualisieren

Lass uns die tatsächlichen Schlusskurse gegen beide Prognosemethoden mit Matplotlib plotten.

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()Bereitgestellt von

Das Diagramm zeigt, wie eng Timestral die tatsächlichen Apple-Preise über 60 Handelstage verfolgt. Beide Ansätze erfassen den Aufwärtstrend, die orange Schattierung ist das 10–90-%-Intervall der Rohpreis-Prognose. Unten siehst du die täglichen Prognosefehler.

Die meisten Fehler bleiben innerhalb von etwa 5 $, mit wenigen größeren Ausreißern von 9 bis 11 $ bei plötzlichen Bewegungen. Beide Methoden liefern nahezu identische Vorhersagen, mit einem leichten Vorteil für Log-Returns. Beide Prognoselinien hängen dem Ist-Preis zudem etwa um einen Tag hinterher – passend zum kleinen Abstand zur naiven Basislinie.

6. Buy-, Hold- und Sell-Signale erzeugen

Jetzt wandeln wir die Rohpreis-Prognosen in experimentelle Buy-, Hold- und Sell-Signale um. Wir verwenden einen Schwellwert von 1 % auf die erwartete Preisänderung:

• BUY: Erwarteter Preisanstieg größer als 1 %.
• SELL: Erwarteter Preisrückgang größer als 1 %.
• HOLD: Erwartete Preisbewegung zwischen -1 % und +1 %.

Mit NumPy lassen sich diese Regeln so umsetzen:

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")Bereitgestellt von

Alle 60 Handelstage ergaben HOLD-Signale, ohne BUY- oder SELL-Empfehlungen. In den gezeigten letzten 10 Zeilen überschreitet die erwartete Veränderung in keiner Richtung 0,15 % – deutlich unter unserem 1-%-Schwellwert.

Diese Signale basieren auf den Rohpreis-Prognosen, die die schwächere Richtungstrefferquote (41,67 %) hatten. Um Signale aus den Log-Return-Prognosen zu sehen, ersetze in der Berechnung von change_pct price_predictions durch return_predictions. Ein niedrigerer Schwellwert erzeugt mehr BUY- und SELL-Signale, macht sie aber auch anfälliger für Prognosefehler und Marktrauschen.

Diese Signale sind zum Experimentieren gedacht, nicht für Live-Trading, und nichts in diesem Tutorial ist Finanzberatung. Weitere Backtests, Feintuning der Schwellenwerte und eine Analyse von Transaktionskosten wären nötig, um zu klären, ob sich daraus eine profitable Strategie ableiten lässt.

Fazit

Insgesamt bin ich von Timestral wirklich beeindruckt. 

Die Einrichtung war unkompliziert, die Inferenz schnell, und ich konnte alles lokal auf meiner RTX 4070 ausführen – ganz ohne externe APIs. 

Besonders attraktiv ist, dass diese leichten Modelle auch auf CPUs laufen – ganz ohne teure Hardware.

Bei der Prognosegenauigkeit sind die Ergebnisse gemischt. 

Timestral folgte den Kursen ordentlich, übertraf die einfache Basislinie aber nur knapp.

Ich bin kein Profi für Finanzprognosen oder Trading – mit besserer Datenaufbereitung, Forecasting-Strategien und Parametertuning ließe sich sicher mehr herausholen.

Ich habe zuvor gehostete Prognosedienste wie TimeGPT genutzt, doch Timestral macht lokale Forecasts deutlich attraktiver. Seit der Veröffentlichung verlagere ich mehr Workloads auf lokale Modelle, weil sie schnell, leichtgewichtig und frei von API-Calls und nutzungsabhängigen Gebühren sind.

Für mich ist Timestrals größte Stärke nicht nur die Genauigkeit, sondern wie einfach und günstig es Forecasting macht.

Du kannst ein leistungsfähiges Zeitreihenmodell auf eigener Hardware betreiben, frei experimentieren und es in Anwendungen integrieren – ohne von externen Diensten abhängig zu sein. Auch wenn unsere Aktienprognosen nicht überragend waren, ist Timestral für alle, die lokale Forecasting-Anwendungen bauen, eine ausgezeichnete Option.

Wenn du tiefer in Forecasting einsteigen willst, empfehle ich unseren Kurs Time Series Analysis in Python. Für finanzspezifische Modelle probiere Machine Learning for Finance in Python.