Zaman Serisi Tahmini için Mistral Timestral’ı Yerelde Nasıl Çalıştırırsınız

Ya küçük, yerelde çalışan, milisaniyeler içinde tahmin döndüren ve ek eğitime ihtiyaç duymayan bir yapay zeka modeliyle hisse senedi fiyatlarını tahmin edebilseydiniz?

Zaman serisi tahmini genellikle ARIMA gibi istatistiksel yöntemler, makine öğrenimi hatları veya belirli bir veri kümesi üzerinde eğitilmiş modeller anlamına gelir. 15 Ekim 2026’da Mistral AI tarafından yayımlanan açık ağırlıklı tahmin modeli ailesi Timestral farklı bir yaklaşım benimsiyor. İnce ayar gerektirmeden geçmiş verilerden gelecekteki değerleri tahmin ediyor ve Mistral’a göre en büyük modeli, üç kamu kıyaslamasında önceden eğitilmiş sıfır-atış (zero-shot) modeller arasında birinci sırada yer alıyor.

Küçük boyutlarına rağmen bu modeller, birden çok tahmin kıyaslamasında rekabetçi doğruluk sunuyor ve finansal piyasalardan enerji tüketimine, perakende talebine kadar geniş bir yelpazede uygulanabiliyor.

Bu eğitimde Timestral’ın ne olduğunu ve nasıl çalıştığını inceleyecek, Python ve uv ile yerelde kuracak ve gerçek Apple (AAPL) hisse verisi üzerinde test edeceğiz. Yuvarlanan bir günlük tahminler üretecek, bunları gerçek kapanış fiyatları ve basit bir naif dayanak ile karşılaştıracak ve tahminleri Basit Al, Sat veya Tut sinyallerine dönüştüreceğiz. Ayrıca TimeGPT ile zaman serisi tahmini ve zaman serisi tahmini için ARIMA üzerine eğitimlerimize de göz atabilirsiniz.

Mistral Timestral Nedir?

Timestral, Mistral AI tarafından hızlı ve genel amaçlı tahmin için sunulan, açık ağırlıklı bir zaman serisi temel model ailesidir. Bir zaman serisi temel modeli, çok çeşitli büyük bir seri koleksiyonunda bir kez önceden eğitilir; böylece daha önce görmediği verileri de tahmin edebilir.

Belirli bir veri kümesi üzerinde eğitime ihtiyaç duyan geleneksel tahmin modellerinin aksine, Timestral sıfır-atış (zero-shot) tahmini destekler. Ek eğitim veya ince ayar olmadan, yalnızca geçmiş verilerden gelecekteki değerleri doğrudan tahmin eder.

Timestral, ağırlıklı olarak sentetik verilerle eğitilmiş, ardından gerçek ve sentetik verilerin karışımıyla ikinci bir eğitim aşaması uygulanan nedensel, yama tabanlı bir dönüştürücüdür (transformer). Hisse senedi fiyatları, enerji talebi, satışlar ve sensör ölçümleriyle başa çıkabilir. Mistral, mimariyi ve eğitimi teknik raporunda açıklıyor.

Mistral, model boyutu, hız ve doğruluk arasında farklı dengeler sunan dört boyut yayımladı:

Mistral’ın yayımladığı kıyaslamalara göre, Timestral-209M, GIFT-Eval, TIME ve fev-bench üzerinde önceden eğitilmiş ve sıfır-atış modeller arasında birinci sırada. Raporlanan karşılaştırmalarda TimesFM-3 ve Falcon-2.0 gibi daha büyük modelleri geride bırakıyor. Bunlar Mistral’ın kendi sonuçları; GIFT-Eval ve TIME lider tablolarına gönderilmiş durumda, bu nedenle bağımsız doğrulama için lider tablolara bakın.

Hız da bir diğer avantaj. 8 iş parçacıklı standart bir sunucu CPU’sunda Mistral, Timestral-209M’in 15 dakikalık geçmişten üç haftalık veriyle bir gün ileri tahmini 113 milisaniyede yaptığını, 5M modelin ise 17 milisaniye sürdüğünü bildiriyor. GPU gerekmiyor.

Timestral şu tahmin özelliklerini destekler:

• Uzun geçmiş bağlamı: 32.768’e kadar geçmiş zaman adımı kabul eder.
• Çok değişkenli tahmin: Tahminleri iyileştirmek için birbiriyle ilişkili birden çok zaman serisini birlikte tahmin eder.
• Olasılıksal tahminler: Tek bir değer yerine, tahmin belirsizliğini kestirmek için 21 kantil döndürür.
• Eş değişkenler: Tahmini etkileyebilecek, yalnızca geçmişe ait ve geleceği bilinen sayısal veya kategorik değişkenleri kabul eder.
• Yerel çıkarım: Ücretli bir API olmadan CPU’lar ve GPU’larda çalışır. Kod Apache 2.0, ağırlıklar ise değiştirilmiş bir MIT lisansı altında yayımlanır.

Bu eğitim için, Mistral’ın yayımladığı kıyaslamalara göre ailenin en büyük ve en doğru modeli olan Timestral-209M’i kullanacağız. Hisse senedi fiyatlarını tahmin etmek ve modeli gerçek piyasa verileri üzerinde değerlendirmek için NVIDIA RTX 4070 GPU üzerinde yerelde çalıştıracağız.

Linux’ta Timestral’ı Kurun

Timestral, Python 3.10 veya üzeri ve PyTorch 2.4 veya üzeri gerektirir. Linux makinede hafif bir geliştirme ortamı oluşturmak için Python 3.12, PyTorch 2.7.0 ve uv kullanacağız. Timestral CPU üzerinde çıkarımı da destekler; GPU isteğe bağlıdır.

Önce NVIDIA GPU’nuzun algılandığını ve sürücülerinin çalıştığını doğrulayın:

nvidia-smiAltyapı:

Bu komut GPU bilgileriniz, sürücü sürümü ve CUDA uyumluluğunu gösterir. GPU’nuz çıktıdaysa devam edebilirsiniz.

Ardından hızlı bir Python paket ve ortam yöneticisi olan uv’yi kurun:

curl -LsSf https://astral.sh/uv/install.sh | shAltyapı:

uv’yi kurduktan sonra terminalinizi yeniden başlatın ki komut kabuğunuzda kullanılabilir hale gelsin.

Şimdi bir proje klasörü ve Python 3.12 sanal ortamı oluşturun:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateAltyapı:

Sonra CUDA 12.6 destekli PyTorch 2.7.0’ı kurun:

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

Testlerimizde, CUDA 12.8 derlemesi RTX 4070’imizde sürücü uyumluluk hatası verdi. PyTorch 2.7.0 ve CUDA 12.6’ya geçmek, sürücüyü güncellemeden sorunu çözdü. GPU’nuz ve NVIDIA sürücünüze bağlı olarak farklı bir CUDA derlemesine ihtiyaç duyabilirsiniz.

GPU’nuz yoksa, dizin URL’sini https://download.pytorch.org/whl/cpu ile değiştirerek CPU derlemesini kurun. Bu eğitimde daha sonra yer alan kod, otomatik olarak CPU’ya geri döner.

Şimdi Timestral’ı doğrudan resmi GitHub deposundan kurun:

uv pip install git+https://github.com/mistralai/timestral.gitAltyapı:

Borsa verilerini indirmek, tahminleri işlemek, görselleştirmeler oluşturmak ve not defterleri çalıştırmak için kalan kütüphaneleri kurun:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmAltyapı:

Geçmiş hisse fiyatlarını almak için yfinance’ı, veri işleme için pandas ve NumPy’yi, gerçek ve tahmini fiyatları çizmek için Matplotlib’i kullanıyoruz. Ayrıca, uyarılardan kaçınmak için pandas sürümünü testlerimizde kullandığımız aralığa sınırlıyoruz.

Devam etmeden önce, PyTorch’un GPU’ya erişebildiğini doğrulayın:

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')"Altyapı:

Bizim çıktımız:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Altyapı:

True değeri, CUDA’nın PyTorch’a kullanılabilir olduğunu doğrular ve son satır GPU’yu belirtir. Artık Timestral ile denemelere başlamaya hazırız.

Ayrı Python betikleri yerine, kodu adım adım çalıştırmak, tahmin değerlerini incelemek ve tahminleri gerçek piyasa verileriyle karşılaştırmak için JupyterLab kullanacağız. Proje klasörünüzden JupyterLab’i başlatın:

python -m jupyter labAltyapı:

Terminalinizde gösterilen URL’yi açın, genellikle http://localhost:8888/lab, ve az önce yapılandırdığımız ortamı kullanarak yeni bir Python not defteri oluşturun. Bu not defterini Timestral’ı yüklemek, tahminler üretmek ve modelin ne kadar iyi performans gösterdiğini değerlendirmek için kullanacağız.

Timestral ile Apple Hisse Fiyatlarını Tahmin Edin

Sentetik veri üretmek yerine, gerçek Apple hisse senedi geçmiş fiyatlarını kullanacak ve Timestral’ın bir sonraki işlem gününün kapanış fiyatını ne kadar doğru tahmin ettiğini ölçeceğiz.

Daha gerçekçi olması için yuvarlanan bir günlük tahmin kullanacağız. Test dönemindeki her işlem günü için Timestral önceki 500 kapanış fiyatını alacak ve yalnızca sonraki günün kapanışını tahmin edecek.

Ayrıca iki yöntemi karşılaştıracağız:

• Ham fiyat tahmini: Bir sonraki kapanış fiyatını doğrudan tahmin edin.
• Log-getiri tahmini: Bir sonraki logaritmik fiyat değişimini tahmin edin ve bunu kapanış fiyatına geri çevirin.

1. Geçmiş hisse fiyatlarını indirin

Bir not defteri başlatın ve gerekli kütüphaneleri içe aktarın. Ayrıca sembolü, test günü sayısını, bağlam penceresini ve model adını ayarlıyoruz.

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"Altyapı:

Şimdi beş yıllık günlük Apple hisse verilerini indirin. auto_adjust=True ayarı, kapanış fiyatlarını bölünmeler ve temettüler için ayarlayarak döndürür.

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())Altyapı:

Test için son 60 işlem seansını ve her tahmin için önceki 500 gözlemi bağlam olarak kullanıyoruz.

2. Timestral’ı GPU’nuzda yükleyin

209M modeli GPU’ya yükleyin; CUDA mevcut değilse CPU’ya geri dönsün. Bu hücreyi ilk kez çalıştırdığınızda 837 MB’lık ağırlıklar Hugging Face’ten indirilir.

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

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

print(f"Loaded {MODEL} on {device}")Altyapı:

Modelimiz RTX 4070 üzerinde başarıyla yüklendi:

Loaded mistralai/Timestral-209M on cudaAltyapı:

3. Yuvarlanan bir günlük tahminler üretin

Şimdi her işlem günü için iki tahmin üretiyoruz: biri geçmiş kapanış fiyatlarından, diğeri log getirilerinden. Log getiri, fiyatın logaritmasındaki günbegün değişimdir; her tahmini getiriyi önceki kapanışı kullanarak tekrar fiyata çeviririz.

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())Altyapı:

Model, her biri için önceki 500 kapanış fiyatını kullanarak 60 yuvarlanan bir günlük tahmin üretir. Her tahmin, yalnızca hedef günden önce mevcut olan verileri kullanır; böylece gelecekteki fiyatlar model girdilerine sızamaz.

4. Tahmin doğruluğunu değerlendirin

Ortalama mutlak hata (MAE), kök ortalama kare hata (RMSE), ortalama mutlak yüzde hata (MAPE) ve yön doğruluğunu ölçüyoruz. Ayrıca yarının kapanış fiyatının bugünküyle aynı olacağını varsayan naif bir dayanağa karşı Timestral’ı kıyaslıyoruz.

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}%")Altyapı:

Sonuçlarımız, Timestral’ın ham hisse fiyatları yerine log getirilerini tahmin ederken biraz daha iyi performans gösterdiğini ortaya koyuyor. 

Log-getiri yaklaşımı, en düşük MAE (3,05 $), RMSE (3,84 $) ve MAPE (%0,93) değerlerine ulaştı ve dayanak modelimizi kıl payı geride bıraktı. 

Daha da önemlisi, yön doğruluğu ham fiyatlarda %41,67’den log getirilerinde %55’e yükseldi; bu da fiyatların yükselip düşeceğini tahmin etmede daha iyi performansa işaret ediyor. 

Ham-fiyat modeli ayrıca beklenen %80’e yakın, %81,7 tahmin aralığı kapsaması elde etti; bu da belirsizlik kestirimlerinin makul derecede kalibre olduğunu gösteriyor. Genel olarak Timestral oldukça doğru fiyat tahminleri üretti; ancak basit dayanak üzerindeki iyileşme sınırlı kaldı ve tahminlerinin işlem kararlarını güvenilir şekilde destekleyip destekleyemeyeceğini anlamak için daha fazla test gerekiyor.

5. Timestral tahminlerini görselleştirin

Gerçek kapanış fiyatlarını her iki tahmin yöntemiyle birlikte Matplotlib kullanarak çizelim.

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()Altyapı:

Grafik, Timestral’ın 60 işlem günü boyunca Apple’ın gerçek fiyatlarını ne kadar yakından takip ettiğini gösteriyor. Her iki yaklaşım da yükseliş eğilimini yakalıyor ve turuncu gölgeli alan, ham-fiyat modelinin %10-90 tahmin aralığını gösteriyor. Alt panel günlük tahmin hatalarını çiziyor.

Hataların çoğu yaklaşık 5 $ içinde kalıyor; ani fiyat hareketlerinde 9 ila 11 $’lık birkaç daha büyük sapma var. İki yöntem neredeyse özdeş tahminler üretiyor; log getirileri az farkla önde. Her iki tahmin çizgisi de gerçek fiyatın yaklaşık bir gün gerisinde seyrediyor; bu da naif dayanağa olan küçük farkla uyumlu.

6. Al, Tut ve Sat sinyalleri üretin

Şimdi ham-fiyat tahminlerini deneysel Al, Tut ve Sat sinyallerine dönüştürelim. Tahmin edilen fiyat değişiminde %1 eşik kullanıyoruz:

• AL: Tahmin edilen fiyat artışı %1’den büyük.
• SAT: Tahmin edilen fiyat düşüşü %1’den büyük.
• TUT: Tahmin edilen fiyat hareketi -%1 ile +%1 arasında.

Bu kuralları NumPy ile uygulayabiliriz:

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")Altyapı:

Tüm 60 işlem günü TUT sinyali üretti; AL veya SAT önerisi yok. Gösterilen son 10 satırda beklenen değişim her iki yönde de hiçbir zaman %0,15’i aşmıyor; bu da %1 eşiğimizin çok altında.

Bu sinyaller, yön doğruluğu daha zayıf olan (%%41,67) ham-fiyat tahminlerinden geliyor. Bunun yerine log-getiri tahminlerinden sinyal görmek için, change_pct hesabında price_predictions’ı return_predictions ile değiştirin. Daha düşük bir eşik daha fazla AL ve SAT sinyali üretir; ancak bunları tahmin hatalarına ve piyasa gürültüsüne daha duyarlı hale getirir.

Bu sinyaller deneyseldir, canlı işlem için değildir ve bu eğitimde hiçbir şey finansal tavsiye değildir. Karlı bir stratejiyi destekleyip destekleyemeyeceklerini anlamak için daha fazla geriye dönük test, eşik ayarı ve işlem maliyeti analizi gerekir.

Son Düşünceler

Genel olarak Timestral’dan gerçekten etkilendim. 

Kurulum bütünüyle basitti, çıkarım hızlıydı ve harici API’lere güvenmeden her şeyi RTX 4070’imde yerelde çalıştırabildim. 

Daha da cazip kılan, bu hafif modellerin CPU’larda da çalışabilmesi; böylece pahalı donanım olmadan erişilebilir olmaları.

Tahmin doğruluğu söz konusu olduğunda ise sonuçlarımız karışıktı. 

Timestral hisse fiyatlarını makul derecede takip etti; ancak basit bir dayanağı zar zor geride bıraktı.

Finansal tahmin veya al–sat konusunda uzman değilim; bu nedenle daha iyi sonuçlar için veri hazırlama, tahmin stratejileri ve parametre ayarlarıyla yapılabilecek daha çok şey olduğuna inanıyorum.

Daha önce TimeGPT gibi barındırılan tahmin servislerini kullandım; ancak Timestral yerel tahmini çok daha cazip hale getirdi. Yayınlandığından beri, performanslı, hafif ve API çağrıları ile kullanım bazlı ücretlerden bağımsız oldukları için tahmin iş yüklerimin daha fazlasını yerel modellere taşımaya başladım.

Benim için Timestral’ın en büyük gücü yalnızca doğruluk değil, tahmini ne kadar kolay ve düşük maliyetli hale getirmesi.

Kendi donanımınızda yetenekli bir zaman serisi modelini çalıştırabilir, özgürce deneyebilir ve harici servislere bağımlı olmadan uygulamalara entegre edebilirsiniz. Hisse tahminlerimiz etkileyici olmasa da, yerel tahmin uygulamaları geliştiren herkes için Timestral’ın mükemmel bir seçenek olduğunu düşünüyorum.

Daha fazla tahmin içeriği öğrenmek isterseniz Python ile Zaman Serisi Analizi kursumuza göz atmanızı öneririm. Finans odaklı modelleme için ise Python ile Finansta Makine Öğrenimi kursunu deneyin.