Cum rulezi local Mistral Timestral pentru prognoza seriilor temporale

Ce-ar fi dacă ai putea prognoza prețurile acțiunilor cu un model AI mic, care rulează local, întoarce predicții în milisecunde și nu are nevoie de antrenare suplimentară?

Prognoza pe serii temporale înseamnă de obicei metode statistice precum ARIMA, pipeline-uri de machine learning sau modele antrenate pe un set de date specific. Timestral, o familie de modele de prognoză cu greutăți deschise lansată de Mistral AI pe 15 octombrie 2026, abordează problema altfel. Prezice valorile viitoare din date istorice fără fine-tuning și, conform Mistral, cel mai mare model al său se clasează pe primul loc între modelele pre-antrenate zero-shot pe trei benchmark-uri publice.

În ciuda dimensiunii reduse, modelele oferă acuratețe competitivă pe multiple benchmark-uri de prognoză și pot fi aplicate de la piețe financiare la consum de energie și cerere în retail.

În acest tutorial, vom vedea ce este Timestral și cum funcționează, îl vom configura local cu Python și uv, și îl vom testa pe date reale pentru acțiunea Apple (AAPL). Vom genera prognoze derulante pe o zi, le vom compara cu prețurile reale de închidere și cu un baseline naiv și vom transforma predicțiile în semnale simple Buy, Sell sau Hold. Poți vedea și tutorialele noastre despre prognoza seriilor temporale cu TimeGPT și ARIMA pentru prognoza seriilor temporale.

Ce este Mistral Timestral?

Timestral este o familie de modele fundamentale pentru serii temporale, cu greutăți deschise, de la Mistral AI, pentru prognoză rapidă, cu scop general. Un model fundamental de serii temporale este pre-antrenat o singură dată pe o colecție mare și variată de serii, astfel încât poate prognoza date pe care nu le-a văzut.

Spre deosebire de modelele tradiționale de prognoză care au nevoie de antrenare pe un set de date specific, Timestral suportă prognoză zero-shot. Prezice valorile viitoare direct din date istorice, fără antrenare sau fine-tuning suplimentar.

Timestral este un transformer cauzal, bazat pe patch-uri, antrenat în mare parte pe date sintetice, urmate de o a doua etapă de antrenare pe un mix de date reale și sintetice. Gestionează prețuri de acțiuni, cerere de energie, vânzări și măsurători de senzori. Mistral descrie arhitectura și antrenarea în raportul tehnic.

Mistral a lansat patru dimensiuni, fiecare cu un compromis diferit între mărimea modelului, viteză și acuratețe:

Conform benchmark-urilor publicate de Mistral, Timestral-209M se clasează pe primul loc între modelele pre-antrenate și zero-shot pe GIFT-Eval, TIME și fev-bench. Îi depășește pe modele mai mari precum TimesFM-3 și Falcon-2.0 în comparațiile raportate. Acestea sunt rezultatele proprii ale Mistral, trimise către leaderboard-urile GIFT-Eval și TIME, așa că verifică leaderboard-urile pentru confirmare independentă.

Viteza este un alt avantaj. Pe un CPU de server standard cu 8 thread-uri, Mistral raportează că Timestral-209M prognozează cu o zi înainte pornind de la trei săptămâni de istoric la 15 minute în 113 milisecunde, iar modelul de 5M are nevoie de 17 milisecunde. Nu este necesar GPU.

Timestral suportă aceste funcționalități de prognoză:

• Context istoric lung: Acceptă până la 32.768 pași de timp istorici.
• Prognoză multivariată: Prognozează mai multe serii temporale înrudite împreună pentru a îmbunătăți predicțiile.
• Predicții probabilistice: Returnează 21 de cuantile pentru a estima incertitudinea prognozei, în locul unei singure valori.
• Covariate: Acceptă variabile doar-din-trecut și cunoscute-în-viitor, numerice sau categorice, care pot influența prognoza.
• Inferență locală: Rulează pe CPU-uri și GPU-uri fără un API plătit. Codul este publicat sub Apache 2.0, iar greutățile sub o licență MIT modificată.

Pentru acest tutorial, vom folosi Timestral-209M, cel mai mare și mai precis model din familie conform benchmark-urilor publicate de Mistral. Îl vom rula local pe un NVIDIA RTX 4070 GPU pentru a prognoza prețuri de acțiuni și a-i evalua performanța pe date reale de piață.

Configurează Timestral pe Linux

Timestral are nevoie de Python 3.10 sau mai nou și PyTorch 2.4 sau mai nou. Noi vom folosi Python 3.12, PyTorch 2.7.0 și uv pentru a crea un mediu de dezvoltare ușor pe o mașină Linux. Timestral suportă și inferență pe CPU, deci GPU-ul este opțional.

Mai întâi, verifică dacă GPU-ul tău NVIDIA este detectat și driverele funcționează:

nvidia-smiFuncționează cu

Această comandă afișează informații despre GPU, versiunea driverului și compatibilitatea CUDA. Dacă GPU-ul apare în output, poți continua.

Apoi, instalează uv, un manager rapid de pachete și medii Python:

curl -LsSf https://astral.sh/uv/install.sh | shFuncționează cu

Repornește terminalul după instalarea uv ca să devină disponibilă comanda în shell.

Acum creează un director de proiect și un mediu virtual Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateFuncționează cu

Apoi, instalează PyTorch 2.7.0 cu suport CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Funcționează cu

În timpul testelor, build-ul CUDA 12.8 a aruncat o eroare de compatibilitate a driverului pe RTX 4070-ul nostru. Trecerea la PyTorch 2.7.0 cu CUDA 12.6 a rezolvat-o fără update de driver. În funcție de GPU-ul și driverul tău NVIDIA, s-ar putea să ai nevoie de alt build CUDA.

Dacă nu ai GPU, instalează în schimb build-ul pentru CPU înlocuind index URL-ul cu https://download.pytorch.org/whl/cpu. Codul de mai târziu din acest tutorial revine automat pe CPU.

Acum instalează Timestral direct din repository-ul oficial de pe GitHub:

uv pip install git+https://github.com/mistralai/timestral.gitFuncționează cu

Instalează bibliotecile rămase pentru descărcarea datelor de piață, procesarea predicțiilor, crearea de vizualizări și rularea de notebook-uri:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmFuncționează cu

Folosim yfinance pentru a prelua prețuri istorice ale acțiunilor, pandas și NumPy pentru procesare de date și Matplotlib pentru a desena prețurile reale versus cele prezise. De asemenea, restrângem versiunea pandas la intervalul folosit în timpul testelor ca să evităm avertismente legate de compatibilitate.

Înainte de a continua, verifică dacă PyTorch poate accesa GPU-ul:

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')"Funcționează cu

Output-ul nostru:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Funcționează cu

Valoarea True confirmă că CUDA este disponibil pentru PyTorch, iar ultima linie identifică GPU-ul. Suntem gata să începem să experimentăm cu Timestral.

În loc de scripturi Python separate, vom folosi JupyterLab ca să putem rula codul pas cu pas, să inspectăm valorile prognozelor și să comparăm predicțiile cu date reale de piață. Lansează JupyterLab din directorul proiectului:

python -m jupyter labFuncționează cu

Deschide URL-ul afișat în terminal, de obicei http://localhost:8888/lab, și creează un notebook Python nou folosind mediul pe care tocmai l-am configurat. Vom folosi acest notebook pentru a încărca Timestral, a genera predicții și a evalua cât de bine performează modelul.

Prognozează prețurile acțiunilor Apple cu Timestral

În loc să generăm date sintetice, vom folosi prețuri istorice reale ale acțiunilor Apple și vom măsura cât de precis prezice Timestral prețul de închidere al următoarei zile de tranzacționare.

Pentru ca experimentul să fie mai realist, vom folosi prognoză derulantă pe o zi. Pentru fiecare zi de tranzacționare din perioada de test, Timestral primește precedentele 500 de prețuri de închidere și prezice doar închiderea din ziua următoare.

Vom compara și două metode:

• Prognoza pe preț brut: Prezice direct următorul preț de închidere.
• Prognoza pe randament logaritmic: Prezice următoarea schimbare logaritmică a prețului și o convertește înapoi într-un preț de închidere.

1. Descarcă prețuri istorice ale acțiunilor

Pornește un notebook și importă bibliotecile necesare. Setăm și tickerul, numărul de zile de test, fereastra de context și numele modelului.

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"Funcționează cu

Acum descarcă cinci ani de date zilnice pentru acțiunea Apple. Setarea auto_adjust=True întoarce prețuri de închidere ajustate pentru split-uri și dividende.

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())Funcționează cu

Folosim ultimele 60 de sesiuni de tranzacționare pentru testare și precedentele 500 de observații ca context pentru fiecare predicție.

2. Încarcă Timestral pe GPU-ul tău

Încarcă modelul de 209M pe GPU, cu fallback pe CPU dacă CUDA nu este disponibil. Cei 837 MB de greutăți se descarcă de pe Hugging Face prima dată când rulezi această celulă.

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

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

print(f"Loaded {MODEL} on {device}")Funcționează cu

Modelul nostru s-a încărcat cu succes pe RTX 4070:

Loaded mistralai/Timestral-209M on cudaFuncționează cu

3. Generează prognoze derulante pe o zi

Acum generăm două predicții pentru fiecare zi de tranzacționare: una din prețurile de închidere istorice și una din randamente logaritmice. Un randament logaritmic este schimbarea de la o zi la alta în logaritmul prețului, iar fiecare randament prezis este convertit înapoi într-un preț folosind închiderea anterioară.

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())Funcționează cu

Modelul generează 60 de prognoze derulante pe o zi, folosind precedentele 500 de prețuri de închidere pentru fiecare. Fiecare prognoză folosește doar date disponibile înainte de ziua țintă, astfel încât prețurile viitoare nu pot ajunge în intrările modelului.

4. Evaluează acuratețea prognozelor

Măsurăm eroarea medie absolută (MAE), rădăcina pătrată a erorii medii pătratice (RMSE), eroarea medie procentuală absolută (MAPE) și acuratețea direcțională. Comparăm și Timestral cu un baseline naiv care presupune că prețul de închidere de mâine va fi egal cu cel de azi.

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}%")Funcționează cu

Rezultatele noastre arată că Timestral performează ușor mai bine când prognozează randamente logaritmice în loc de prețuri brute. 

Abordarea pe randamente logaritmice a obținut cel mai mic MAE (3,05 $), RMSE (3,84 $) și MAPE (0,93%), depășind la limită modelul nostru baseline. 

Mai important, acuratețea direcțională a crescut de la 41,67% cu prețuri brute la 55% cu randamente logaritmice, sugerând o performanță mai bună în a prezice dacă prețurile vor crește sau vor scădea. 

Modelul pe preț brut a obținut, de asemenea, o acoperire a intervalului de predicție de 81,7%, aproape de 80% așteptat, indicând estimări ale incertitudinii rezonabil calibrate. Per total, Timestral a generat prognoze de preț destul de precise, dar îmbunătățirea față de baseline-ul simplu a fost minimă, iar testări suplimentare sunt necesare pentru a stabili dacă predicțiile pot susține în mod fiabil decizii de tranzacționare.

5. Vizualizează predicțiile Timestral

Hai să desenăm prețurile reale de închidere versus ambele metode de prognoză folosind 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()Funcționează cu

Graficul arată cât de îndeaproape urmărește Timestral prețurile reale ale Apple pe parcursul celor 60 de zile de tranzacționare. Ambele abordări surprind trendul ascendent, iar zona portocalie umbrită este intervalul de predicție 10-90% al modelului pe preț brut. Panoul de jos desenează erorile zilnice ale predicțiilor.

Majoritatea erorilor rămân în jur de 5 $, cu câteva depășiri mai mari de 9 până la 11 $ în timpul mișcărilor bruște de preț. Cele două metode produc prognoze aproape identice, cu un mic avans pentru randamentele logaritmice. Ambele linii de prognoză rămân și cu aproximativ o zi în urma prețului real, ceea ce se potrivește cu diferența mică față de baseline-ul naiv.

6. Generează semnale Buy, Hold și Sell

Acum să convertim predicțiile pe preț brut în semnale experimentale Buy, Hold și Sell. Folosim un prag de 1% pe schimbarea de preț prezisă:

• BUY: Creștere de preț prezisă mai mare de 1%.
• SELL: Scădere de preț prezisă mai mare de 1%.
• HOLD: Mișcare de preț prezisă între -1% și +1%.

Putem implementa aceste reguli cu 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")Funcționează cu

Toate cele 60 de zile de tranzacționare au produs semnale HOLD, fără recomandări BUY sau SELL. În ultimele 10 rânduri afișate, schimbarea așteptată nu depășește niciodată 0,15% în nicio direcție, mult sub pragul nostru de 1%.

Aceste semnale provin din predicțiile pe preț brut, care au avut acuratețe direcțională mai slabă (41,67%). Pentru a vedea semnale din prognozele pe randamente logaritmice, înlocuiește price_predictions cu return_predictions în calculul change_pct. Un prag mai mic ar produce mai multe semnale BUY și SELL, dar le-ar face și mai sensibile la erorile de prognoză și la zgomotul pieței.

Aceste semnale sunt pentru experimentare, nu pentru tranzacționare live, și nimic din acest tutorial nu reprezintă sfat financiar. Ar fi necesare backtesting suplimentar, ajustarea pragurilor și analiza costurilor de tranzacționare ca să afli dacă pot susține o strategie profitabilă.

Gânduri finale

Per total, sunt foarte impresionat de Timestral. 

Întregul setup a fost simplu, inferența a fost rapidă și am putut rula totul local pe RTX 4070 fără să depind de API-uri externe. 

Și mai atrăgător este că aceste modele ușoare pot rula și pe CPU-uri, făcându-le accesibile fără hardware scump.

Când vine vorba de acuratețea prognozelor, rezultatele noastre au fost mixte. 

Timestral a urmărit prețurile acțiunilor destul de bine, dar a depășit cu puțin un baseline simplu.

Nu sunt expert în prognoză financiară sau tranzacționare, așa că probabil aș putea îmbunătăți rezultatele prin pregătirea datelor, strategii de prognoză și reglaje de parametri.

Am folosit anterior servicii găzduite de prognoză precum TimeGPT, dar Timestral a făcut prognoza locală mult mai atractivă. De la lansare, am început să mut mai multe workload-uri de prognoză pe modele locale, pentru că sunt rapide, ușoare și nu depind de apeluri API și tarife pe utilizare.

Pentru mine, cel mai mare atu al Timestral nu este doar acuratețea, ci cât de ușoară și ieftină face prognoza.

Poți rula un model capabil de serii temporale pe propriul hardware, poți experimenta liber și îl poți integra în aplicații fără să depinzi de servicii externe. Chiar dacă predicțiile noastre pe acțiuni nu au fost impresionante, cred că Timestral este o opțiune excelentă pentru oricine construiește aplicații locale de prognoză.

Dacă vrei să înveți mai multe despre prognoză, îți recomand cursul nostru Time Series Analysis in Python. Pentru modelare specifică în finanțe, încearcă Machine Learning for Finance in Python.