Jak uruchomić Mistral Timestral lokalnie do prognozowania szeregów czasowych

Co by było, gdybyś mógł prognozować ceny akcji małym modelem AI, który działa lokalnie, zwraca prognozy w milisekundach i nie wymaga dodatkowego treningu?

Prognozowanie szeregów czasowych zwykle oznacza metody statystyczne, takie jak ARIMA, potoki uczenia maszynowego lub modele trenowane na konkretnym zbiorze danych. Timestral, rodzina modeli prognozowania o otwartych wagach wydana przez Mistral AI 15 października 2026 r., podchodzi do tego inaczej. Przewiduje przyszłe wartości na podstawie danych historycznych bez fine-tuningu, a według Mistral jego największy model zajmuje pierwsze miejsce wśród wstępnie wytrenowanych modeli zero-shot na trzech publicznych benchmarkach.

Mimo niewielkich rozmiarów, modele zapewniają konkurencyjną dokładność na wielu benchmarkach prognozowania i można je zastosować do wszystkiego — od rynków finansowych po zużycie energii i popyt w handlu detalicznym.

W tym tutorialu zobaczymy, czym jest Timestral i jak działa, skonfigurujemy go lokalnie w Pythonie i z uv, a następnie przetestujemy na prawdziwych danych akcji Apple (AAPL). Wygenerujemy kroczące jednodniowe prognozy, porównamy je z rzeczywistymi cenami zamknięcia i naiwną bazą odniesienia oraz zamienimy prognozy w proste sygnały Kup, Sprzedaj lub Trzymaj. Zobacz też nasze tutoriale o prognozowaniu szeregów czasowych z TimeGPT i ARIMA do prognozowania szeregów czasowych.

Czym jest Mistral Timestral?

Timestral to rodzina bazowych modeli szeregów czasowych od Mistral AI do szybkiego, ogólnego prognozowania. Bazowy model szeregów czasowych jest wstępnie trenowany raz na dużej, zróżnicowanej kolekcji szeregów, dzięki czemu potrafi prognozować dane, których wcześniej nie widział.

W przeciwieństwie do tradycyjnych modeli prognozowania, które wymagają treningu na konkretnym zbiorze danych, Timestral wspiera prognozowanie zero-shot. Przewiduje przyszłe wartości bezpośrednio z danych historycznych, bez dodatkowego treningu czy fine-tuningu.

Timestral to przyczynowy, oparty na patchach transformer trenowany głównie na danych syntetycznych, a następnie w drugiej fazie na miksie danych rzeczywistych i syntetycznych. Radzi sobie z cenami akcji, zapotrzebowaniem na energię, sprzedażą i pomiarami z czujników. Mistral opisuje architekturę i trening w raporcie technicznym.

Mistral udostępnił cztery rozmiary, każdy z innym kompromisem między wielkością, szybkością i dokładnością:

Zgodnie z opublikowanymi benchmarkami Mistral, Timestral-209M zajmuje pierwsze miejsce wśród wstępnie wytrenowanych modeli zero-shot na GIFT-Eval, TIME i fev-bench. W pokazywanych porównaniach pokonuje większe modele, takie jak TimesFM-3 i Falcon-2.0. To wyniki własne Mistral, zgłoszone na listy rankingowe GIFT-Eval i TIME, więc sprawdź rankingi dla niezależnego potwierdzenia.

Szybkość to kolejna zaleta. Na standardowym serwerowym CPU z 8 wątkami Mistral raportuje, że Timestral-209M prognozuje dzień naprzód na podstawie trzech tygodni historii w interwale 15-minutowym w 113 milisekund, a model 5M potrzebuje 17 milisekund. GPU nie jest wymagane.

Timestral wspiera następujące funkcje prognozowania:

• Długi kontekst historyczny: Przyjmuje do 32 768 historycznych kroków czasowych.
• Prognozowanie wielowymiarowe: Prognozuje wiele powiązanych szeregów jednocześnie, aby poprawić trafność.
• Prognozy probabilistyczne: Zwraca 21 kwantyli do oszacowania niepewności prognozy zamiast pojedynczej wartości.
• Kowariaty: Przyjmuje zmienne tylko z przeszłości oraz znane z przyszłości, numeryczne lub kategoryczne, które mogą wpływać na prognozę.
• Wnioskowanie lokalne: Działa na CPU i GPU bez płatnego API. Kod jest wydany na licencji Apache 2.0, a wagi na zmodyfikowanej licencji MIT.

W tym tutorialu użyjemy Timestral-209M, największego i według opublikowanych benchmarków Mistral najdokładniejszego modelu z tej rodziny. Uruchomimy go lokalnie na NVIDIA RTX 4070, aby prognozować ceny akcji i ocenić jego skuteczność na prawdziwych danych rynkowych.

Skonfiguruj Timestral na Linuksie

Timestral wymaga Pythona 3.10 lub nowszego oraz PyTorch 2.4 lub nowszego. Użyjemy Pythona 3.12, PyTorch 2.7.0 i uv, aby stworzyć lekkie środowisko deweloperskie na maszynie z Linuksem. Timestral wspiera też wnioskowanie na CPU, więc GPU jest opcjonalne.

Najpierw sprawdź, czy twój GPU NVIDIA jest wykryty i czy sterowniki działają:

nvidia-smiObsługiwane przez

To polecenie wyświetla informacje o GPU, wersji sterownika i zgodności z CUDA. Jeśli w wynikach widzisz swój GPU, możesz przejść dalej.

Następnie zainstaluj uv, szybki menedżer pakietów i środowisk Pythona:

curl -LsSf https://astral.sh/uv/install.sh | shObsługiwane przez

Uruchom ponownie terminal po instalacji uv, aby polecenie było dostępne w powłoce.

Teraz utwórz katalog projektu i wirtualne środowisko dla Pythona 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateObsługiwane przez

Następnie zainstaluj PyTorch 2.7.0 ze wsparciem CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Obsługiwane przez

Podczas testów build CUDA 12.8 wyrzucał błąd zgodności sterownika na naszym RTX 4070. Przejście na PyTorch 2.7.0 z CUDA 12.6 rozwiązało problem bez aktualizacji sterownika. W zależności od twojego GPU i sterownika NVIDIA możesz potrzebować innego buildu CUDA.

Jeśli nie masz GPU, zainstaluj zamiast tego build CPU, zamieniając adres indeksu na https://download.pytorch.org/whl/cpu. Kod później w tym tutorialu automatycznie przełączy się na CPU.

Teraz zainstaluj Timestral bezpośrednio z oficjalnego repozytorium GitHub:

uv pip install git+https://github.com/mistralai/timestral.gitObsługiwane przez

Zainstaluj pozostałe biblioteki do pobierania danych giełdowych, przetwarzania prognoz, tworzenia wizualizacji i uruchamiania notebooków:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmObsługiwane przez

Używamy yfinance do pobierania historycznych cen akcji, pandas i NumPy do przetwarzania danych, a Matplotlib do wykresów cen rzeczywistych versus prognozowanych. Ograniczamy też wersję pandas do zakresu używanego w testach, aby uniknąć ostrzeżeń związanych ze zgodnością.

Przed dalszymi krokami sprawdź, czy PyTorch ma dostęp do twojego 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')"Obsługiwane przez

Nasze wyjście:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Obsługiwane przez

Wartość True potwierdza, że CUDA jest dostępna dla PyTorch, a ostatnia linia identyfikuje GPU. Możemy zaczynać eksperymenty z Timestral.

Zamiast osobnych skryptów Pythona użyjemy JupyterLab, aby uruchamiać kod krok po kroku, przeglądać wartości prognoz i porównywać je z rzeczywistymi danymi rynkowymi. Uruchom JupyterLab z katalogu projektu:

python -m jupyter labObsługiwane przez

Otwórz adres wyświetlony w terminalu, zwykle http://localhost:8888/lab, i utwórz nowy notebook Pythona, używając właśnie skonfigurowanego środowiska. W tym notebooku załadujemy Timestral, wygenerujemy prognozy i ocenimy skuteczność modelu.

Prognozuj ceny akcji Apple z Timestral

Zamiast tworzyć dane syntetyczne, użyjemy prawdziwych historycznych cen akcji Apple i zmierzymy, jak trafnie Timestral przewiduje cenę zamknięcia kolejnego dnia sesyjnego.

Aby eksperyment był bardziej realistyczny, zastosujemy kroczące prognozowanie jednodniowe. Dla każdego dnia sesyjnego w okresie testowym Timestral otrzymuje 500 poprzednich cen zamknięcia i przewiduje wyłącznie zamknięcie kolejnego dnia.

Porównamy też dwie metody:

• Prognozowanie cen surowych: Bezpośrednia predykcja kolejnej ceny zamknięcia.
• Prognozowanie log-zwrotów: Predykcja kolejnej logarytmicznej zmiany ceny i konwersja z powrotem na cenę zamknięcia.

1. Pobierz historyczne ceny akcji

Uruchom notebook i zaimportuj wymagane biblioteki. Ustawimy też ticker, liczbę dni testowych, okno kontekstu i nazwę modelu.

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"Obsługiwane przez

Teraz pobierz pięć lat dziennych danych Apple. Ustawienie auto_adjust=True zwraca ceny zamknięcia skorygowane o splity i dywidendy.

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())Obsługiwane przez

Używamy ostatnich 60 sesji giełdowych do testów oraz poprzedzających 500 obserwacji jako kontekstu dla każdej prognozy.

2. Załaduj Timestral na GPU

Załaduj model 209M na GPU, z przejściem na CPU, jeśli CUDA nie jest dostępna. 837 MB wag pobiera się z Hugging Face przy pierwszym uruchomieniu tej komórki.

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

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

print(f"Loaded {MODEL} on {device}")Obsługiwane przez

Model załadował się pomyślnie na RTX 4070:

Loaded mistralai/Timestral-209M on cudaObsługiwane przez

3. Generuj kroczące prognozy jednodniowe

Teraz wygenerujemy po dwie prognozy dla każdego dnia sesyjnego: jedną z historycznych cen zamknięcia i jedną z log-zwrotów. Log-zwrot to dzienna zmiana logarytmu ceny; każdą przewidzianą wartość zwrotu konwertujemy z powrotem na cenę przy użyciu poprzedniego zamknięcia.

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())Obsługiwane przez

Model generuje 60 kroczących prognoz jednodniowych, używając za każdym razem poprzednich 500 cen zamknięcia. Każda prognoza wykorzystuje wyłącznie dane dostępne przed dniem docelowym, więc przyszłe ceny nie wyciekają do wejść modelu.

4. Oceń dokładność prognoz

Mierzymy średni błąd bezwzględny (MAE), pierwiastek średniego błędu kwadratowego (RMSE), średni procentowy błąd bezwzględny (MAPE) oraz trafność kierunku. Porównujemy też Timestral z naiwną bazą, która zakłada, że jutrzejsza cena zamknięcia równa się dzisiejszej.

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}%")Obsługiwane przez

Nasze wyniki pokazują, że Timestral działa nieco lepiej przy prognozowaniu log-zwrotów niż surowych cen akcji. 

Podejście z log-zwrotami osiągnęło najniższe MAE (3,05 USD), RMSE (3,84 USD) i MAPE (0,93%), minimalnie wyprzedzając nasz model bazowy. 

Co ważniejsze, trafność kierunku wzrosła z 41,67% dla surowych cen do 55% dla log-zwrotów, co sugeruje lepsze przewidywanie, czy ceny wzrosną, czy spadną. 

Model surowych cen uzyskał też 81,7% pokrycia przedziału predykcyjnego, blisko oczekiwanych 80%, co wskazuje na dość dobrze skalibrowane oszacowania niepewności. Ogólnie Timestral wygenerował całkiem trafne prognozy cen, ale jego przewaga nad prostą bazą była minimalna i potrzebne są dalsze testy, aby ocenić, czy prognozy mogą wiarygodnie wspierać decyzje inwestycyjne.

5. Zwizualizuj prognozy Timestral

Narysujmy rzeczywiste ceny zamknięcia i obie metody prognoz za pomocą 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()Obsługiwane przez

Wykres pokazuje, jak blisko Timestral podąża za rzeczywistymi cenami Apple w ciągu 60 sesji. Oba podejścia wychwytują trend wzrostowy, a zacieniony pomarańczowy obszar to przedział 10–90% dla modelu surowych cen. Dolny panel przedstawia dzienne błędy prognoz.

Większość błędów mieści się w ok. 5 USD, z kilkoma większymi pudłami 9–11 USD przy nagłych ruchach cen. Obie metody dają niemal identyczne prognozy, z lekką przewagą log-zwrotów. Obie linie prognoz także opóźniają się względem ceny rzeczywistej o ok. jeden dzień, co współgra z niewielką przewagą nad naiwną bazą.

6. Generuj sygnały Kup, Trzymaj i Sprzedaj

Teraz zamieńmy prognozy surowych cen na eksperymentalne sygnały Kup, Trzymaj i Sprzedaj. Używamy progu 1% na przewidywanej zmianie ceny:

• KUP: Przewidywany wzrost ceny większy niż 1%.
• SPRZEDAJ: Przewidywany spadek ceny większy niż 1%.
• TRZYMAJ: Przewidywany ruch ceny między −1% a +1%.

Możemy zaimplementować te reguły w 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")Obsługiwane przez

Wszystkie 60 dni sesyjnych wygenerowało sygnały TRZYMAJ, bez rekomendacji KUP lub SPRZEDAJ. W ostatnich 10 wierszach oczekiwana zmiana nigdy nie przekracza 0,15% w żadną stronę, czyli znacznie poniżej naszego progu 1%.

Te sygnały pochodzą z prognoz surowych cen, które miały słabszą trafność kierunku (41,67%). Aby zobaczyć sygnały z prognoz log-zwrotów, podmień price_predictions na return_predictions w obliczeniu change_pct. Niższy próg wygenerowałby więcej sygnałów KUP i SPRZEDAJ, ale uczyniłby je też bardziej wrażliwymi na błędy prognoz i szum rynkowy.

To sygnały do eksperymentów, nie do handlu na żywo, i nic w tym tutorialu nie stanowi porady finansowej. Potrzebne byłyby dalsze testy wsteczne, strojenie progów i analiza kosztów transakcyjnych, aby sprawdzić, czy mogą wspierać zyskowną strategię.

Wnioski końcowe

Ogólnie Timestral zrobił na mnie naprawdę dobre wrażenie. 

Cała konfiguracja była prosta, wnioskowanie szybkie, a wszystko mogłem uruchomić lokalnie na RTX 4070 bez polegania na zewnętrznych API. 

Co więcej, te lekkie modele działają też na CPU, więc są dostępne bez drogiego sprzętu.

Jeśli chodzi o dokładność prognoz, wyniki były mieszane. 

Timestral całkiem nieźle śledził ceny akcji, ale ledwie wyprzedził prostą bazę.

Nie jestem ekspertem od prognoz finansowych ani handlu, więc pewnie mógłbym więcej zdziałać dzięki przygotowaniu danych, strategiom prognozowania i strojeniu parametrów, aby uzyskać lepsze wyniki.

Wcześniej korzystałem z hostowanych usług prognozowania, takich jak TimeGPT, ale Timestral sprawił, że lokalne prognozowanie stało się dużo atrakcyjniejsze. Od czasu premiery zacząłem przenosić więcej zadań prognozowania na modele lokalne, bo są szybkie, lekkie i wolne od wywołań API oraz opłat zależnych od użycia.

Dla mnie największą siłą Timestral nie jest sama dokładność, ale to, jak łatwe i tanie staje się prognozowanie.

Możesz uruchomić kompetentny model szeregów czasowych na własnym sprzęcie, swobodnie eksperymentować i wbudować go w aplikacje bez zależności od usług zewnętrznych. Nawet jeśli nasze prognozy akcji nie były imponujące, uważam, że Timestral to świetna opcja dla każdego, kto buduje lokalne aplikacje do prognozowania.

Jeśli chcesz zgłębić prognozowanie, polecam nasz kurs Time Series Analysis in Python. Do modelowania finansowego wypróbuj Machine Learning for Finance in Python.