Comment exécuter Mistral Timestral en local pour la prévision de séries temporelles

Et si vous pouviez prévoir les cours boursiers avec un petit modèle d’IA qui s’exécute en local, renvoie des prédictions en quelques millisecondes et ne nécessite aucun entraînement supplémentaire ?

La prévision de séries temporelles rime généralement avec des méthodes statistiques comme ARIMA, des pipelines de machine learning, ou des modèles entraînés sur un jeu de données spécifique. Timestral, une famille de modèles de prévision à poids ouverts publiée par Mistral AI le 15 octobre 2026, propose une autre approche. Il prédit les valeurs futures à partir des données historiques sans affinage, et selon Mistral, son plus grand modèle arrive en tête des modèles préentraînés en zero-shot sur trois benchmarks publics.

Malgré leur petite taille, ces modèles offrent une précision compétitive sur de multiples benchmarks de prévision et peuvent s’appliquer à tout, des marchés financiers à la consommation d’énergie en passant par la demande retail.

Dans ce tutoriel, nous allons voir ce qu’est Timestral et comment il fonctionne, le configurer en local avec Python et uv, puis le tester sur des données réelles de l’action Apple (AAPL). Nous générerons des prévisions glissantes à un jour, les comparerons aux cours de clôture réels et à un point de départ naïf, et transformerons les prédictions en signaux simples d’achat, de vente ou de conservation. Vous pouvez également consulter nos tutoriels sur la prévision de séries temporelles avec TimeGPT et sur ARIMA pour la prévision de séries temporelles.

Qu’est-ce que Mistral Timestral ?

Timestral est une famille de modèles fondamentaux de séries temporelles à poids ouverts, conçue par Mistral AI pour des prévisions rapides et polyvalentes. Un modèle fondamental de séries temporelles est préentraîné une fois sur un vaste ensemble hétérogène de séries afin de pouvoir prévoir des données qu’il n’a jamais vues.

Contrairement aux modèles traditionnels qui nécessitent un entraînement sur un jeu de données spécifique, Timestral prend en charge la prévision zero-shot. Il prédit directement les valeurs futures à partir des données historiques, sans entraînement ni affinage supplémentaires.

Timestral est un transformeur causal par blocs (patch-based), entraîné principalement sur des données synthétiques, puis affiné lors d’une seconde phase sur un mélange de données réelles et synthétiques. Il gère les cours boursiers, la demande énergétique, les ventes et les mesures de capteurs. Mistral décrit l’architecture et l’entraînement dans son rapport technique.

Mistral a publié quatre tailles, chacune avec un compromis différent entre taille du modèle, vitesse et précision :

Selon les benchmarks publiés par Mistral, Timestral-209M arrive en tête des modèles préentraînés et zero-shot sur GIFT-Eval, TIME et fev-bench. Il surpasse des modèles plus grands comme TimesFM-3 et Falcon-2.0 dans les comparaisons rapportées. Ce sont les propres résultats de Mistral, soumis aux classements GIFT-Eval et TIME, donc vérifiez les leaderboards pour une confirmation indépendante.

La vitesse est un autre atout. Sur un CPU de serveur standard avec 8 threads, Mistral indique que Timestral-209M prévoit un jour à partir de trois semaines d’historique à 15 minutes en 113 millisecondes, et le modèle 5M met 17 millisecondes. Aucun GPU n’est requis.

Timestral prend en charge les fonctionnalités de prévision suivantes :

• Long contexte historique : accepte jusqu’à 32 768 pas de temps historiques.
• Prévision multivariée : prévoit plusieurs séries temporelles liées conjointement pour améliorer les prédictions.
• Prédictions probabilistes : renvoie 21 quantiles pour estimer l’incertitude, plutôt qu’une seule valeur.
• Covariables : accepte des variables passées uniquement et connues à l’avance, numériques ou catégorielles, susceptibles d’influencer la prévision.
• Inférence locale : s’exécute sur CPU et GPU sans API payante. Le code est sous licence Apache 2.0 et les poids sous une licence MIT modifiée.

Pour ce tutoriel, nous utiliserons Timestral-209M, le modèle le plus grand et le plus précis de la famille selon les benchmarks publiés par Mistral. Nous l’exécuterons en local sur un GPU NVIDIA RTX 4070 pour prévoir les cours boursiers et évaluer ses performances sur des données de marché réelles.

Configurer Timestral sous Linux

Timestral nécessite Python 3.10 ou supérieur et PyTorch 2.4 ou supérieur. Nous utiliserons Python 3.12, PyTorch 2.7.0 et uv pour créer un environnement de développement léger sur une machine Linux. Timestral prend aussi en charge l’inférence sur CPU, donc le GPU est optionnel.

Commencez par vérifier que votre GPU NVIDIA est détecté et que ses pilotes fonctionnent :

nvidia-smiPropulsé par

Cette commande affiche les informations de votre GPU, la version du pilote et la compatibilité CUDA. Si votre GPU apparaît dans la sortie, vous pouvez continuer.

Ensuite, installez uv, un gestionnaire rapide de paquets et d’environnements Python :

curl -LsSf https://astral.sh/uv/install.sh | shPropulsé par

Redémarrez votre terminal après l’installation d’uv pour que la commande soit disponible dans votre shell.

Créez maintenant un répertoire de projet et un environnement virtuel Python 3.12 :

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activatePropulsé par

Installez ensuite PyTorch 2.7.0 avec la prise en charge de CUDA 12.6 :

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Propulsé par

Lors de nos tests, la build CUDA 12.8 a généré une erreur de compatibilité de pilote sur notre RTX 4070. Passer à PyTorch 2.7.0 avec CUDA 12.6 a résolu le problème sans mise à jour du pilote. Selon votre GPU et votre pilote NVIDIA, vous pourriez avoir besoin d’une autre build CUDA.

Si vous n’avez pas de GPU, installez plutôt la build CPU en remplaçant l’URL d’index par https://download.pytorch.org/whl/cpu. Le code plus loin dans ce tutoriel basculera automatiquement sur le CPU.

Installez maintenant Timestral directement depuis son dépôt GitHub officiel :

uv pip install git+https://github.com/mistralai/timestral.gitPropulsé par

Installez les bibliothèques restantes pour télécharger des données de marché, traiter les prédictions, créer des visualisations et exécuter des notebooks :

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmPropulsé par

Nous utilisons yfinance pour récupérer les cours historiques, pandas et NumPy pour le traitement des données, et Matplotlib pour tracer les prix réels vs prédits. Nous contraignons aussi la version de pandas à la plage utilisée pendant nos tests afin d’éviter des avertissements de compatibilité.

Avant de continuer, vérifiez que PyTorch peut accéder à votre 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')"Propulsé par

Notre sortie :

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Propulsé par

La valeur True confirme que CUDA est disponible pour PyTorch, et la dernière ligne identifie le GPU. Nous sommes maintenant prêts à expérimenter avec Timestral.

Plutôt que des scripts Python séparés, nous utiliserons JupyterLab pour exécuter le code pas à pas, inspecter les valeurs prévues et comparer les prédictions aux données de marché réelles. Lancez JupyterLab depuis votre répertoire de projet :

python -m jupyter labPropulsé par

Ouvrez l’URL affichée dans votre terminal, généralement http://localhost:8888/lab, et créez un nouveau notebook Python avec l’environnement que nous venons de configurer. Nous utiliserons ce notebook pour charger Timestral, générer des prédictions et évaluer les performances du modèle.

Prévoir le cours d’Apple avec Timestral

Plutôt que de générer des données synthétiques, nous utiliserons des cours historiques réels d’Apple et mesurerons la capacité de Timestral à prédire le cours de clôture du jour de bourse suivant.

Pour rendre l’expérience plus réaliste, nous utiliserons des prévisions glissantes à un jour. Pour chaque jour de bourse de la période de test, Timestral reçoit les 500 derniers cours de clôture et ne prédit que la clôture du jour suivant.

Nous comparerons également deux méthodes :

• Prévision sur prix bruts : prédire directement le prochain cours de clôture.
• Prévision sur rendements logarithmiques : prédire la prochaine variation logarithmique du prix puis la reconvertir en cours de clôture.

1. Télécharger les cours historiques

Démarrez un notebook et importez les bibliothèques nécessaires. Nous définissons aussi le ticker, le nombre de jours de test, la fenêtre de contexte et le nom du modèle.

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"Propulsé par

Téléchargez maintenant cinq ans de données quotidiennes sur l’action Apple. Le paramètre auto_adjust=True renvoie des cours ajustés des splits et dividendes.

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())Propulsé par

Nous utilisons les 60 dernières séances pour le test et les 500 observations précédentes comme contexte pour chaque prédiction.

2. Charger Timestral sur votre GPU

Chargez le modèle 209M sur le GPU, avec repli sur le CPU si CUDA n’est pas disponible. Les 837 Mo de poids sont téléchargés depuis Hugging Face lors de la première exécution de cette cellule.

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

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

print(f"Loaded {MODEL} on {device}")Propulsé par

Notre modèle s’est chargé avec succès sur la RTX 4070 :

Loaded mistralai/Timestral-209M on cudaPropulsé par

3. Générer des prévisions glissantes à un jour

Nous générons maintenant deux prédictions pour chaque jour de bourse : l’une à partir des cours de clôture historiques et l’autre à partir des rendements logarithmiques. Un rendement logarithmique est la variation jour à jour du logarithme du prix, que nous reconvertissons ensuite en prix à partir de la clôture précédente.

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())Propulsé par

Le modèle génère 60 prévisions glissantes à un jour, en utilisant les 500 derniers cours de clôture pour chacune. Chaque prévision n’utilise que les données disponibles avant le jour cible, de sorte que les prix futurs ne peuvent pas fuiter dans les entrées du modèle.

4. Évaluer la précision des prévisions

Nous mesurons l’erreur absolue moyenne (MAE), la racine de l’erreur quadratique moyenne (RMSE), l’erreur absolue moyenne en pourcentage (MAPE) et la précision directionnelle. Nous comparons aussi Timestral à un point de départ naïf qui suppose que la clôture de demain sera égale à celle d’aujourd’hui.

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}%")Propulsé par

Nos résultats montrent que Timestral fonctionne légèrement mieux en prévoyant les rendements logarithmiques plutôt que les prix bruts.

L’approche par rendements log a obtenu les meilleurs scores : MAE (3,05 $), RMSE (3,84 $) et MAPE (0,93 %), dépassant de peu notre modèle de référence.

Plus important, la précision directionnelle est passée de 41,67 % avec les prix bruts à 55 % avec les rendements log, suggérant une meilleure capacité à prédire si le cours va monter ou baisser.

Le modèle sur prix bruts a également atteint une couverture d’intervalle de 81,7 % pour la plage 10–90 %, proche des 80 % attendus, ce qui indique des estimations d’incertitude plutôt bien calibrées. Globalement, Timestral a généré des prévisions de prix assez correctes, mais son gain par rapport au point de départ naïf est resté minime, et des tests supplémentaires sont nécessaires pour déterminer si ses prédictions peuvent soutenir des décisions de trading de manière fiable.

5. Visualiser les prédictions de Timestral

Traçons les cours de clôture réels face aux deux méthodes de prévision avec 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()Propulsé par

Le graphique montre à quel point Timestral colle aux prix réels d’Apple sur 60 séances. Les deux approches capturent la tendance haussière, et la zone orange ombrée représente l’intervalle de prévision 10–90 % du modèle sur prix bruts. Le panneau du bas trace les erreurs quotidiennes.

La plupart des erreurs restent autour de 5 $, avec quelques écarts plus marqués de 9 à 11 $ lors de mouvements brusques. Les deux méthodes produisent des prévisions presque identiques, avec un léger avantage pour les rendements log. Les deux courbes de prévision accusent aussi un léger retard d’environ une journée par rapport au prix réel, ce qui correspond au faible écart avec la base naïve.

6. Générer des signaux Buy, Hold et Sell

Convertissons maintenant les prédictions sur prix bruts en signaux expérimentaux d’achat (Buy), de conservation (Hold) et de vente (Sell). Nous utilisons un seuil de 1 % sur la variation de prix prévue :

• BUY : hausse prévue supérieure à 1 %.
• SELL : baisse prévue supérieure à 1 %.
• HOLD : mouvement prévu entre -1 % et +1 %.

Nous pouvons implémenter ces règles avec 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")Propulsé par

Toutes les 60 séances ont produit des signaux HOLD, sans recommandation BUY ni SELL. Dans les 10 dernières lignes affichées, la variation attendue n’excède jamais 0,15 % dans un sens comme dans l’autre, bien en dessous de notre seuil de 1 %.

Ces signaux proviennent des prédictions sur prix bruts, qui présentaient la plus faible précision directionnelle (41,67 %). Pour obtenir des signaux à partir des rendements log, remplacez price_predictions par return_predictions dans le calcul de change_pct. Un seuil plus bas produirait davantage de signaux BUY et SELL, mais ils seraient aussi plus sensibles aux erreurs de prévision et au bruit de marché.

Ces signaux servent à l’expérimentation, pas au trading réel, et rien dans ce tutoriel ne constitue un conseil financier. Des backtests supplémentaires, un ajustement des seuils et une analyse des coûts de transaction seraient nécessaires pour déterminer s’ils peuvent soutenir une stratégie rentable.

En conclusion

Globalement, Timestral m’a vraiment impressionné.

La mise en place était simple, l’inférence rapide, et j’ai pu tout exécuter en local sur ma RTX 4070 sans dépendre d’APIs externes.

Encore mieux, ces modèles légers tournent aussi sur CPU, ce qui les rend accessibles sans matériel onéreux.

Côté précision des prévisions, nos résultats sont mitigés.

Timestral a suivi les cours de manière raisonnable, mais il a à peine dépassé un point de départ simple.

Je ne suis pas expert en prévision financière ni en trading, donc il y a probablement davantage à faire en préparation des données, stratégies de prévision et réglages de paramètres pour obtenir de meilleurs résultats.

J’ai auparavant utilisé des services hébergés comme TimeGPT, mais Timestral rend la prévision locale beaucoup plus attractive. Depuis sa sortie, j’ai commencé à basculer davantage de charges de prévision vers des modèles locaux car ils sont rapides, légers et sans appels d’API ni frais à l’usage.

Pour moi, la plus grande force de Timestral n’est pas seulement sa précision, mais la simplicité et le faible coût qu’il apporte à la prévision.

Vous pouvez exécuter un modèle de séries temporelles performant sur votre propre matériel, expérimenter librement et l’intégrer à des applications sans dépendre de services externes. Même si nos prédictions boursières n’étaient pas spectaculaires, je pense que Timestral est une excellente option pour quiconque construit des applications de prévision locales.

Si vous souhaitez aller plus loin en prévision, je vous recommande notre cours Time Series Analysis in Python. Pour la modélisation orientée finance, essayez Machine Learning for Finance in Python.