Come eseguire Mistral Timestral in locale per il forecasting di serie temporali

E se potessi prevedere i prezzi azionari con un piccolo modello di AI che gira in locale, restituisce previsioni in millisecondi e non richiede alcun training aggiuntivo?

Il forecasting di serie temporali di solito significa metodi statistici come ARIMA, pipeline di machine learning o modelli addestrati su un dataset specifico. Timestral, una famiglia di modelli di forecasting open-weight rilasciata da Mistral AI il 15 ottobre 2026, adotta un approccio diverso. Prevede i valori futuri a partire dai dati storici senza fine-tuning e, secondo Mistral, il suo modello più grande si classifica al primo posto tra i modelli pretrained zero-shot su tre benchmark pubblici.

Nonostante le dimensioni ridotte, i modelli offrono un'accuratezza competitiva su più benchmark di forecasting e possono essere applicati a tutto, dai mercati finanziari ai consumi energetici e alla domanda retail.

In questo tutorial vedremo cos'è Timestral e come funziona, come configurarlo in locale con Python e uv, e lo testeremo su dati reali del titolo Apple (AAPL). Genereremo previsioni rolling a un giorno, le confronteremo con i prezzi di chiusura effettivi e con una baseline ingenua, e trasformeremo le previsioni in semplici segnali Buy, Sell o Hold. Puoi anche dare un'occhiata ai nostri tutorial su time series forecasting con TimeGPT e ARIMA per il forecasting di serie temporali.

Che cos'è Mistral Timestral?

Timestral è una famiglia di foundation model open-weight per serie temporali di Mistral AI, pensata per un forecasting rapido e general-purpose. Un foundation model per serie temporali è pre-addestrato una volta su una vasta e variegata collezione di serie, così da poter prevedere dati mai visti.

A differenza dei modelli tradizionali di forecasting che richiedono training su un dataset specifico, Timestral supporta il forecasting zero-shot. Prevede i valori futuri direttamente dai dati storici, senza training o fine-tuning aggiuntivi.

Timestral è un transformer causale, basato su patch, addestrato principalmente su dati sintetici, seguito da una seconda fase di training su un mix di dati reali e sintetici. Gestisce prezzi azionari, domanda di energia, vendite e misurazioni da sensori. Mistral descrive architettura e training nel suo technical report.

Mistral ha rilasciato quattro dimensioni, ciascuna con un diverso compromesso tra grandezza del modello, velocità e accuratezza:

Secondo i benchmark pubblicati da Mistral, Timestral-209M si classifica primo tra i modelli pretrained e zero-shot su GIFT-Eval, TIME e fev-bench. Nelle comparazioni riportate, supera modelli più grandi come TimesFM-3 e Falcon-2.0. Si tratta dei risultati di Mistral, inviati alle leaderboard di GIFT-Eval e TIME, quindi verifica le leaderboard per conferme indipendenti.

La velocità è un altro vantaggio. Su una CPU server standard con 8 thread, Mistral riporta che Timestral-209M prevede un giorno avanti partendo da tre settimane di storico a 15 minuti in 113 millisecondi, e il modello da 5M impiega 17 millisecondi. Non è richiesta una GPU.

Timestral supporta queste funzionalità di forecasting:

• Contesto storico lungo: Accetta fino a 32.768 passi temporali storici.
• Forecasting multivariato: Prevede più serie temporali correlate insieme per migliorare le previsioni.
• Previsioni probabilistiche: Restituisce 21 quantili per stimare l'incertezza, invece di un singolo valore.
• Covariate: Accetta variabili solo passate e note nel futuro, numeriche o categoriali, che possono influenzare la previsione.
• Inferenza locale: Gira su CPU e GPU senza API a pagamento. Il codice è rilasciato sotto Apache 2.0 e i pesi sotto una licenza MIT modificata.

Per questo tutorial useremo Timestral-209M, il modello più grande e accurato della famiglia secondo i benchmark pubblicati da Mistral. Lo eseguiremo in locale su una NVIDIA RTX 4070 per prevedere i prezzi azionari e valutarne le prestazioni su dati reali di mercato.

Configura Timestral su Linux

Timestral richiede Python 3.10 o successivo e PyTorch 2.4 o successivo. Useremo Python 3.12, PyTorch 2.7.0 e uv per creare un ambiente di sviluppo leggero su una macchina Linux. Timestral supporta anche l'inferenza su CPU, quindi la GPU è opzionale.

Per prima cosa, verifica che la tua GPU NVIDIA sia rilevata e che i driver funzionino:

nvidia-smiOfferto da

Questo comando mostra informazioni sulla GPU, versione del driver e compatibilità CUDA. Se la tua GPU compare nell'output, puoi procedere.

Poi installa uv, un gestore veloce di pacchetti ed environment per Python:

curl -LsSf https://astral.sh/uv/install.sh | shOfferto da

Riavvia il terminale dopo aver installato uv in modo che il comando sia disponibile nella tua shell.

Ora crea una directory di progetto e un ambiente virtuale Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateOfferto da

Successivamente, installa PyTorch 2.7.0 con supporto CUDA 12.6:

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

Durante i test, la build CUDA 12.8 ha generato un errore di compatibilità del driver sulla nostra RTX 4070. Passare a PyTorch 2.7.0 con CUDA 12.6 ha risolto senza aggiornare il driver. In base alla tua GPU e al driver NVIDIA, potresti aver bisogno di una build CUDA diversa.

Se non hai una GPU, installa invece la build per CPU sostituendo l'index URL con https://download.pytorch.org/whl/cpu. Il codice più avanti in questo tutorial esegue automaticamente il fallback su CPU.

Ora installa Timestral direttamente dal suo repository GitHub ufficiale:

uv pip install git+https://github.com/mistralai/timestral.gitOfferto da

Installa le librerie rimanenti per scaricare dati di mercato, processare le previsioni, creare visualizzazioni ed eseguire notebook:

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

Usiamo yfinance per recuperare i prezzi storici, pandas e NumPy per l'elaborazione dei dati e Matplotlib per tracciare prezzi effettivi vs previsti. Limitiamo anche la versione di pandas all'intervallo usato durante i test per evitare avvisi dovuti alla compatibilità.

Prima di procedere, verifica che PyTorch possa accedere alla tua 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')"Offerto da

Il nostro output:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Offerto da

Il valore True conferma che CUDA è disponibile per PyTorch e l'ultima riga identifica la GPU. Siamo pronti per iniziare a sperimentare con Timestral.

Invece di script Python separati, useremo JupyterLab così da eseguire il codice passo passo, ispezionare i valori previsti e confrontare le previsioni con i dati reali di mercato. Avvia JupyterLab dalla directory del progetto:

python -m jupyter labOfferto da

Apri l'URL mostrato nel terminale, di solito http://localhost:8888/lab, e crea un nuovo notebook Python usando l'ambiente appena configurato. Useremo questo notebook per caricare Timestral, generare previsioni e valutare le prestazioni del modello.

Prevedi i prezzi Apple con Timestral

Invece di generare dati sintetici, useremo prezzi storici reali di Apple e misureremo quanto accuratamente Timestral prevede il prezzo di chiusura del giorno di trading successivo.

Per rendere l'esperimento più realistico, useremo previsioni rolling a un giorno. Per ogni giorno di trading nel periodo di test, Timestral riceve le 500 chiusure precedenti e prevede solo la chiusura del giorno seguente.

Confronteremo anche due metodi:

• Previsione sul prezzo grezzo: Prevedere direttamente la prossima chiusura.
• Previsione sul log-return: Prevedere la prossima variazione logaritmica del prezzo e riconvertirla in una chiusura.

1. Scarica i prezzi storici

Avvia un notebook e importa le librerie necessarie. Impostiamo anche il ticker, il numero di giorni di test, la finestra di contesto e il nome del modello.

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"Offerto da

Ora scarica cinque anni di dati giornalieri di Apple. Impostando auto_adjust=True ottieni prezzi di chiusura aggiustati per split e dividendi.

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())Offerto da

Usiamo le ultime 60 sessioni di trading per il test e le 500 osservazioni precedenti come contesto per ciascuna previsione.

2. Carica Timestral sulla tua GPU

Carica il modello 209M sulla GPU, con fallback su CPU se CUDA non è disponibile. Gli 837 MB di pesi vengono scaricati da Hugging Face alla prima esecuzione di questa cella.

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

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

print(f"Loaded {MODEL} on {device}")Offerto da

Il nostro modello è stato caricato con successo sulla RTX 4070:

Loaded mistralai/Timestral-209M on cudaOfferto da

3. Genera previsioni rolling a un giorno

Ora generiamo due previsioni per ogni giorno di trading: una dai prezzi di chiusura storici e una dai log-return. Un log-return è la variazione giorno su giorno del logaritmo del prezzo, e convertiamo ogni ritorno previsto in un prezzo usando la chiusura precedente.

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())Offerto da

Il modello genera 60 previsioni rolling a un giorno, usando le 500 chiusure precedenti per ciascuna. Ogni previsione usa solo dati disponibili prima del giorno target, quindi i prezzi futuri non possono infiltrarsi negli input del modello.

4. Valuta l'accuratezza delle previsioni

Misuriamo mean absolute error (MAE), root mean squared error (RMSE), mean absolute percentage error (MAPE) e accuratezza direzionale. Confrontiamo anche Timestral con una baseline ingenua che assume che la chiusura di domani sia uguale a quella di oggi.

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}%")Offerto da

I nostri risultati mostrano che Timestral si comporta leggermente meglio quando prevede i log-return invece dei prezzi grezzi. 

L'approccio con i log-return ha ottenuto i MAE (3,05 $), RMSE (3,84 $) e MAPE (0,93%) più bassi, superando di poco il nostro modello baseline. 

Ancora più importante, l'accuratezza direzionale è passata dal 41,67% con i prezzi grezzi al 55% con i log-return, suggerendo una migliore capacità di prevedere se i prezzi saliranno o scenderanno. 

Il modello sul prezzo grezzo ha anche raggiunto una copertura dell'intervallo di previsione del 81,7%, vicino all'80% atteso, indicando stime di incertezza ragionevolmente calibrate. Nel complesso, Timestral ha generato previsioni di prezzo abbastanza accurate, ma il miglioramento rispetto alla semplice baseline è stato minimo, e saranno necessari ulteriori test per capire se le sue previsioni possano supportare in modo affidabile decisioni di trading.

5. Visualizza le previsioni di Timestral

Tracciamo i prezzi di chiusura effettivi rispetto a entrambi i metodi di forecasting usando 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()Offerto da

Il grafico mostra quanto da vicino Timestral segue i prezzi effettivi di Apple nei 60 giorni di trading. Entrambi gli approcci catturano il trend rialzista, e l'area arancione ombreggiata è l'intervallo di previsione 10-90% del modello sul prezzo grezzo. Il pannello inferiore traccia gli errori giornalieri.

La maggior parte degli errori resta entro circa 5 $, con alcuni scostamenti maggiori di 9-11 $ durante movimenti improvvisi. I due metodi producono previsioni quasi identiche, con un leggero vantaggio per i log-return. Entrambe le linee di previsione inoltre inseguono il prezzo effettivo con circa un giorno di ritardo, in linea con il piccolo divario rispetto alla baseline ingenua.

6. Genera segnali Buy, Hold e Sell

Ora convertiamo le previsioni sul prezzo grezzo in segnali sperimentali Buy, Hold e Sell. Usiamo una soglia dell'1% sulla variazione prevista del prezzo:

• BUY: Aumento previsto del prezzo superiore all'1%.
• SELL: Diminuzione prevista del prezzo superiore all'1%.
• HOLD: Movimento previsto tra -1% e +1%.

Possiamo implementare queste regole con 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")Offerto da

Tutti i 60 giorni di trading hanno prodotto segnali HOLD, senza raccomandazioni BUY o SELL. Nelle ultime 10 righe mostrate, la variazione attesa non supera mai lo 0,15% in nessuna direzione, ben al di sotto della nostra soglia dell'1%.

Questi segnali derivano dalle previsioni sul prezzo grezzo, che avevano un'accuratezza direzionale più debole (41,67%). Per vedere i segnali dalle previsioni sui log-return, sostituisci price_predictions con return_predictions nel calcolo di change_pct. Una soglia più bassa produrrebbe più segnali BUY e SELL, ma li renderebbe anche più sensibili agli errori di previsione e al rumore di mercato.

Questi segnali servono per la sperimentazione, non per il trading live, e nulla in questo tutorial costituisce consulenza finanziaria. Servirebbero ulteriori backtest, ottimizzazione delle soglie e analisi dei costi di transazione per capire se possano supportare una strategia profittevole.

Considerazioni finali

Nel complesso, Timestral mi ha davvero colpito. 

L'intera configurazione è stata semplice, l'inferenza veloce e ho potuto eseguire tutto in locale sulla mia RTX 4070 senza dipendere da API esterne. 

Ancora meglio, questi modelli leggeri possono girare anche su CPU, rendendoli accessibili senza hardware costoso.

Quanto all'accuratezza, i nostri risultati sono stati misti. 

Timestral ha seguito i prezzi azionari in modo ragionevole, ma ha superato di poco una semplice baseline.

Non sono un esperto di forecasting finanziario o trading, quindi probabilmente potrei fare di più con la preparazione dei dati, le strategie di previsione e la messa a punto dei parametri per ottenere risultati migliori.

In passato ho usato servizi di forecasting hosted come TimeGPT, ma Timestral ha reso il forecasting locale molto più interessante. Dalla sua uscita, ho iniziato a spostare più carichi di lavoro di forecasting su modelli locali perché sono veloci, leggeri e liberi da chiamate API e costi basati sull'utilizzo.

Per me, il punto di forza maggiore di Timestral non è solo l'accuratezza, ma quanto renda facile ed economico fare forecasting.

Puoi eseguire un modello di serie temporali capace sull'hardware che già possiedi, sperimentare liberamente e integrarlo nelle applicazioni senza dipendere da servizi esterni. Anche se le nostre previsioni azionarie non sono state impressionanti, penso che Timestral sia un'ottima opzione per chiunque stia costruendo applicazioni di forecasting in locale.

Se vuoi approfondire il forecasting, ti consiglio il nostro corso Time Series Analysis in Python. Per la modellazione specifica per la finanza, prova Machine Learning for Finance in Python.