Så kör du Mistral Timestral lokalt för tidsserieprognoser

Tänk om du kunde prognostisera aktiekurser med en liten AI‑modell som körs lokalt, ger förutsägelser på millisekunder och inte kräver någon extra träning?

Tidsserieprognoser innebär vanligtvis statistiska metoder som ARIMA, maskininlärningspipelines eller modeller tränade på en specifik datamängd. Timestral, en familj av open-weight-prognosmodeller som släpptes av Mistral AI den 15 oktober 2026, tar en annan väg. Den förutsäger framtida värden från historiska data utan finjustering och enligt Mistral rankas den största modellen etta bland förtränade zero-shot-modeller på tre offentliga riktmärken.

Trots sin lilla storlek levererar modellerna konkurrenskraftig noggrannhet över flera prognosbenchmarks och kan användas till allt från finansmarknader till energiförbrukning och detaljhandelsefterfrågan.

I den här handledningen går vi igenom vad Timestral är och hur den fungerar, sätter upp den lokalt med Python och uv, och testar den på verkliga Apple‑data (AAPL). Vi genererar rullande endagsprognoser, jämför dem mot faktiska stängningskurser och en naiv baslinje, och omvandlar förutsägelserna till enkla signaler: Köp, Sälj eller Behåll. Du kan också se våra handledningar om tidsserieprognoser med TimeGPT och ARIMA för tidsserieprognoser.

Vad är Mistral Timestral?

Timestral är en familj av open-weight grundmodeller för tidsserier från Mistral AI för snabba, allmänna prognoser. En grundmodell för tidsserier förtränas en gång på en stor, varierad samling serier, så att den kan prognostisera data den aldrig har sett.

Till skillnad från traditionella prognosmodeller som behöver tränas på en specifik datamängd stödjer Timestral zero-shot-prognoser. Den förutsäger framtida värden direkt från historiska data, utan extra träning eller finjustering.

Timestral är en kausal, patch‑baserad transformer som tränats mestadels på syntetiska data, följt av ett andra träningssteg på en mix av verkliga och syntetiska data. Den hanterar aktiekurser, energiefterfrågan, försäljning och sensormätningar. Mistral beskriver arkitekturen och träningen i sin tekniska rapport.

Mistral släppte fyra storlekar, med olika avvägningar mellan modellstorlek, hastighet och noggrannhet:

Enligt Mistrals publicerade benchmarks rankas Timestral-209M först bland förtränade och zero-shot‑modeller på GIFT-Eval, TIME och fev-bench. Den slår större modeller som TimesFM-3 och Falcon-2.0 i de rapporterade jämförelserna. Det här är Mistrals egna resultat, inskickade till GIFT‑Eval‑ och TIME‑topplistorna, så kontrollera topplistorna för oberoende bekräftelse.

Hastighet är en annan fördel. På en standardserver‑CPU med 8 trådar rapporterar Mistral att Timestral-209M prognostiserar en dag framåt från tre veckors 15‑minutershistorik på 113 millisekunder, och 5M‑modellen tar 17 millisekunder. Ingen GPU krävs.

Timestral stödjer följande prognosfunktioner:

• Långt historiskt sammanhang: Accepterar upp till 32 768 historiska tidsteg.
• Multivariat prognos: Prognostiserar flera relaterade tidsserier tillsammans för att förbättra förutsägelserna.
• Probabilistiska prediktioner: Returnerar 21 kvantiler för att uppskatta osäkerhet, i stället för ett enskilt värde.
• Kovariater: Accepterar både dåtids‑ och kända framtida variabler, numeriska eller kategoriska, som kan påverka prognosen.
• Lokal inferens: Körs på CPU:er och GPU:er utan betald API. Koden släpps under Apache 2.0 och vikterna under en modifierad MIT‑licens.

I den här handledningen använder vi Timestral-209M, den största och mest träffsäkra modellen i familjen enligt Mistrals publicerade benchmarks. Vi kör den lokalt på en NVIDIA RTX 4070‑GPU för att prognostisera aktiekurser och utvärdera prestandan på verkliga marknadsdata.

Installera Timestral på Linux

Timestral kräver Python 3.10 eller senare och PyTorch 2.4 eller senare. Vi använder Python 3.12, PyTorch 2.7.0 och uv för att skapa en lättviktsutvecklingsmiljö på en Linux‑maskin. Timestral stödjer även inferens på CPU, så en GPU är valfri.

Börja med att verifiera att din NVIDIA‑GPU känns igen och att drivrutinerna fungerar:

nvidia-smiDrivs av

Detta kommando visar information om din GPU, drivrutinsversion och CUDA‑kompatibilitet. Om din GPU visas i utdata kan du fortsätta.

Installera sedan uv, en snabb pakethanterare och miljöhanterare för Python:

curl -LsSf https://astral.sh/uv/install.sh | shDrivs av

Starta om terminalen efter att du har installerat uv så att kommandot blir tillgängligt i ditt skal.

Skapa nu en projektkatalog och en virtuell miljö för Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateDrivs av

Installera sedan PyTorch 2.7.0 med CUDA 12.6‑stöd:

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

Under testningen gav CUDA 12.8‑bygget ett fel om drivrutinskompatibilitet på vår RTX 4070. Att byta till PyTorch 2.7.0 med CUDA 12.6 löste det utan drivrutinsuppdatering. Beroende på din GPU och NVIDIA‑drivrutin kan du behöva ett annat CUDA‑bygge.

Om du inte har en GPU, installera CPU‑bygget i stället genom att ersätta index‑URL:en med https://download.pytorch.org/whl/cpu. Koden senare i den här handledningen faller tillbaka på CPU automatiskt.

Installera nu Timestral direkt från dess officiella GitHub‑repo:

uv pip install git+https://github.com/mistralai/timestral.gitDrivs av

Installera återstående bibliotek för att ladda ner börsdata, bearbeta förutsägelser, skapa visualiseringar och köra notebooks:

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

Vi använder yfinance för att hämta historiska aktiekurser, pandas och NumPy för databearbetning, och Matplotlib för att plotta faktiska kontra prognostiserade priser. Vi begränsar också pandas‑versionen till intervallet som användes under våra tester för att undvika kompatibilitetsrelaternade varningar.

Innan du går vidare, verifiera att PyTorch kan använda din 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')"Drivs av

Vår utdata:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Drivs av

Värdet True bekräftar att CUDA är tillgängligt för PyTorch, och sista raden identifierar GPU:n. Nu är vi redo att börja experimentera med Timestral.

I stället för separata Python‑skript använder vi JupyterLab så att vi kan köra kod steg för steg, inspektera prognosvärden och jämföra förutsägelser med faktiska marknadsdata. Starta JupyterLab från din projektkatalog:

python -m jupyter labDrivs av

Öppna URL:en som visas i terminalen, vanligtvis http://localhost:8888/lab, och skapa en ny Python‑notebook med den miljö vi just konfigurerade. Vi använder denna notebook för att ladda Timestral, generera förutsägelser och utvärdera hur bra modellen presterar.

Prognostisera Apples aktiekurser med Timestral

I stället för att generera syntetiska data använder vi verkliga historiska Apple‑kurser och mäter hur träffsäkert Timestral förutsäger nästa handelsdags stängningskurs.

För att göra experimentet mer realistiskt använder vi rullande endagsprognoser. För varje handelsdag i testperioden får Timestral de föregående 500 stängningskurserna och förutsäger endast nästa dags stängning.

Vi jämför också två metoder:

• Råprisprognoser: Förutsäg nästa stängningskurs direkt.
• Logavkastningsprognoser: Förutsäg nästa logaritmiska prisförändring och konvertera tillbaka till stängningskurs.

1. Ladda ner historiska aktiekurser

Starta en notebook och importera nödvändiga bibliotek. Vi sätter också ticker, antal testdagar, kontextfönster och modellnamn.

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"Drivs av

Ladda nu ner fem års dagliga Apple‑data. Med auto_adjust=True returneras stängningskurser justerade för splitar och utdelningar.

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())Drivs av

Vi använder de senaste 60 handelsdagarna för testning och de föregående 500 observationerna som kontext för varje förutsägelse.

2. Ladda Timestral på din GPU

Ladda 209M‑modellen på GPU:n, med fallback till CPU om CUDA inte är tillgängligt. De 837 MB vikterna laddas ner från Hugging Face första gången du kör den här cellen.

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

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

print(f"Loaded {MODEL} on {device}")Drivs av

Vår modell laddades framgångsrikt på RTX 4070:

Loaded mistralai/Timestral-209M on cudaDrivs av

3. Generera rullande endagsprognoser

Nu genererar vi två förutsägelser för varje handelsdag: en från historiska stängningskurser och en från logavkastningar. En logavkastning är den dagliga förändringen i prisets logaritm, och vi omvandlar varje prognostiserad avkastning tillbaka till ett pris med föregående stängning.

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())Drivs av

Modellen genererar 60 rullande endagsprognoser och använder de föregående 500 stängningskurserna för var och en. Varje prognos använder bara data som fanns tillgängliga före måldagen, så framtida priser kan inte läcka in i modellens indata.

4. Utvärdera prognosernas noggrannhet

Vi mäter medelabsolutfel (MAE), rotmedelkvadratfel (RMSE), medelabsolut procentuellt fel (MAPE) och riktningsträff. Vi jämför också Timestral mot en naiv baslinje som antar att morgondagens stängning är lika med dagens.

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}%")Drivs av

Våra resultat visar att Timestral presterar något bättre när den prognostiserar logavkastningar i stället för råa aktiepriser. 

Logavkastningsmetoden nådde lägst MAE ($3,05), RMSE ($3,84) och MAPE (0,93 %) och slog knappt vår baslinjemodell. 

Viktigare är att riktningsträffen förbättrades från 41,67 % med råpriser till 55 % med logavkastningar, vilket antyder bättre förmåga att förutsäga om priserna stiger eller faller. 

Råpris‑modellen uppnådde också 81,7 % täckning för prediktionsintervallet, nära förväntade 80 %, vilket indikerar rimligt kalibrerade osäkerhetsuppskattningar. Sammantaget genererade Timestral ganska träffsäkra prisprognoser, men förbättringen över den enkla baslinjen var minimal, och vidare testning behövs för att avgöra om förutsägelserna pålitligt kan stödja handelsbeslut.

5. Visualisera Timestrals förutsägelser

Låt oss plotta de faktiska stängningskurserna mot båda prognosmetoderna med 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()Drivs av

Diagrammet visar hur nära Timestral följer Apples faktiska priser över de 60 handelsdagarna. Båda metoderna fångar uppåttrenden, och det skuggade orange området är råpris‑modellens 10–90 %‑intervall. Den nedre panelen visar dagliga prognosfel.

De flesta fel håller sig inom cirka 5 $, med några större missar på 9 till 11 $ vid plötsliga prisrörelser. Metoderna ger nästan identiska förutsägelser, med logavkastningar något före. Båda prognoslinjerna släpar också ungefär en dag efter det faktiska priset, vilket stämmer med hur liten skillnaden mot den naiva baslinjen är.

6. Generera Köp-, Behåll- och Sälj‑signaler

Nu konverterar vi råprisprognoserna till experimentella signaler: Köp, Behåll och Sälj. Vi använder en tröskel på 1 % för den prognostiserade prisförändringen:

• KÖP: Prognostiserad prisökning större än 1 %.
• SÄLJ: Prognostiserad prisminskning större än 1 %.
• BEHÅLL: Prognostiserad prisrörelse mellan −1 % och +1 %.

Vi kan implementera dessa regler med 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")Drivs av

Alla 60 handelsdagar gav BEHÅLL‑signaler, utan några KÖP‑ eller SÄLJ‑rekommendationer. I de sista 10 raderna överstiger den förväntade förändringen aldrig 0,15 % åt något håll, långt under vår tröskel på 1 %.

Dessa signaler kommer från råprisprognoserna, som hade svagare riktningsträff (41,67 %). För att se signaler från logavkastningsprognoserna, byt ut price_predictions mot return_predictions i beräkningen av change_pct. En lägre tröskel skulle ge fler KÖP‑ och SÄLJ‑signaler, men också göra dem mer känsliga för prognosfel och marknadsbrus.

Dessa signaler är för experiment, inte livehandel, och inget i den här handledningen är finansiell rådgivning. Ytterligare backtesting, tröskeljustering och analys av transaktionskostnader skulle krävas för att ta reda på om de kan stödja en lönsam strategi.

Avslutande tankar

Sammantaget är jag verkligen imponerad av Timestral. 

Hela installationen var okomplicerad, inferensen gick snabbt och jag kunde köra allt lokalt på min RTX 4070 utan att förlita mig på externa API:er. 

Det som gör det ännu mer tilltalande är att dessa lättviktsmodeller även kan köras på CPU:er, vilket gör dem tillgängliga utan dyr hårdvara.

När det gäller prognosernas träffsäkerhet var våra resultat blandade. 

Timestral följde aktiekurserna hyfsat väl, men överträffade knappt en enkel baslinje.

Jag är ingen expert på finansiella prognoser eller handel, så det finns säkert mer jag skulle kunna göra med datapreparering, prognosstrategier och parametertrimning för att få bättre resultat.

Jag har tidigare använt hostade prognostiseringstjänster som TimeGPT, men Timestral har gjort lokala prognoser betydligt mer attraktiva. Sedan lanseringen har jag börjat flytta fler av mina prognosarbetslaster till lokala modeller eftersom de är snabba, lätta och fria från API‑anrop och användningsbaserade avgifter.

För mig är Timestrals största styrka inte bara noggrannhet, utan hur enkelt och billigt det gör prognostisering.

Du kan köra en kapabel tidsseriemodell på din egen hårdvara, experimentera fritt och bygga in den i applikationer utan att vara beroende av externa tjänster. Även om våra aktieförutsägelser inte var imponerande tycker jag att Timestral är ett utmärkt alternativ för alla som bygger lokala prognosapplikationer.

Om du vill lära dig mer om prognoser rekommenderar jag vår kurs Time Series Analysis in Python. För finansspecifik modellering, prova Machine Learning for Finance in Python.