Zaman Serisi Tahmini 2026: TimeGPT, NeuralProphet, Amazon Chronos ve Lag-Llama Karşılaştırması

2024-2026 arasında zaman serisi tahmini sessiz bir devrim geçirdi. ARIMA ve Prophet gibi istatistiksel araçlar birkaç yıl önce hâlâ tartışmasız standartken, bugün milyonlarca gerçek seriyle ön-eğitimli foundation modeller API çağrısıyla tahmin üretebiliyor, sıfır ek eğitim, sıfır hiperparametre ayarı.

Bu değişimi Türkçe kaynaklarda kapsamlı anlatan bir rehber yoktu. Bu yazı o boşluğu dolduruyor.

Ne öğreneceksiniz:

1. Modern zaman serisi foundation modellerinin mimarisi nasıl çalışır?
2. TimeGPT, NeuralProphet, Amazon Chronos ve Lag-Llama gerçekte ne sunuyor?
3. Klasik ARIMA / Prophet ne zaman hâlâ doğru seçim?
4. Hangi aracı ne zaman seçeceğinizi gösteren pratik karar matrisi
5. Her araç için minimal çalışan Python kodu

Neden 2026’da Zaman Serisi Tahmini Yeniden Önemli?

Zaman serisi verisi her yerde: e-ticaret talep planlaması, enerji şebekesi yük dengesi, fintech fraud anomali tespiti, üretim hattı bakım tahmini, sağlık monitöring. Tahmin kalitesindeki her yüzde puanlık iyileşme, büyük operasyonlarda milyonlarca dolarlık stok/enerji/kapasite tasarrufuna dönüşür.

Klasik araçlar bu bağlamda iki büyük sorunla boğuşuyordu:

• Seri başına eğitim: Her yeni SKU, her yeni enerji sensörü için ayrı model kurmanız gerekiyordu. Binlerce seri varsa bu mimari felce dönüşüyor.
• Ön bilgi gerektirmez: ARIMA d/p/q hiperparametreleri, Prophet tatil takvimleri, XGBoost için manuel özellik mühendisliği, her şeyi alan uzmanı gibi kodluyorsunuz.

Foundation modeller bu iki sorunu tersine çeviriyor: tek modelle binlerce seri, sıfır eğitim gerektiren zero-shot inference.

Klasik Araçlar: ARIMA ve Prophet’i Nerede Durduğunu Anlamak

Modern araçları değerlendirmeden önce referans noktasını netleştirelim.

ARIMA

Autoregressive Integrated Moving Average, 1970’lerden bu yana istatistiksel tahmin standardı. Box-Jenkins metodolojisi: seriyi durağan hale getir (I), geçmiş değerlerle regres yap (AR), hata terimlerini modelleyelim (MA).

from statsmodels.tsa.arima.model import ARIMA
import pandas as pd

df = pd.read_csv("satis.csv", index_col="tarih", parse_dates=True)
y = df["satis"]

model = ARIMA(y, order=(2, 1, 2))
result = model.fit()

forecast = result.forecast(steps=14)
print(forecast)

ARIMA güçlü yönleri:

• Açıklanabilirlik: katsayılar yorumlanabilir
• Az veriyle çalışır (50-100 gözlem yeterli)
• Güçlü teorik temel, güven aralıkları sağlam
• Bağımlılık yok: sadece statsmodels

ARIMA zayıf yönleri:

• Doğrusal ilişkiler varsayar; karmaşık örüntüleri kaçırır
• Her seri için ACF/PACF analizi + d/p/q seçimi gerektirir
• Dış değişken entegrasyonu zahmetli (ARIMAX)
• Binlerce seri ölçeklenmez

Prophet

Meta’nın 2017’de açık kaynaklı hale getirdiği araç, analistler için tasarlandı: trend + mevsimsellik + tatiller. Python API’si kasıtlı olarak veri bilimciden çok iş analistine hitap eder.

from prophet import Prophet
import pandas as pd

df = pd.read_csv("satis.csv")
df = df.rename(columns={"tarih": "ds", "satis": "y"})

m = Prophet(seasonality_mode="multiplicative", yearly_seasonality=True)
m.add_country_holidays(country_name="TR")  # Türk tatilleri
m.fit(df)

future = m.make_future_dataframe(periods=30)
forecast = m.predict(future)
print(forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail(30))

Prophet güçlü yönleri:

• Tatil ve özel gün entegrasyonu kolay
• Decomposition ile trend/mevsimsellik ayrıştırması
• Eksik veri toleransı yüksek

Prophet zayıf yönleri:

• 2023’ten bu yana aktif geliştirme yok
• Kısa seriler ve yüksek frekanslı veri zayıf
• Kapasite etkisi ve lojistik büyüme iyi modellense de karmaşık örüntüler için yetersiz

TimeGPT (Nixtla): Zaman Serisi için İlk Foundation Model API’si

Nixtla’nın 2023’te duyurduğu TimeGPT, zaman serisi tahminini LLM çağrısına indirgeyen ilk ticari foundation modeldir. Öğrenme verisi: 100 milyarı aşkın zaman serisi gözlemi, finans, enerji, sağlık, perakende.

Mimari

TimeGPT, transformer encoder-decoder mimarisi kullanır. Girdi: zaman damgaları + geçmiş değerler (+ opsiyonel dış değişkenler). Çıktı: yüzdelik aralıklarla tahmin.

Asıl yenilik zero-shot generalization: modeli hiç görmediği seri türlerinde tahmin yapabilmesi. Nixtla’nın yayımladığı kıyaslama çalışmaları, 300+ veri seti üzerinde ARIMA ve Prophet’i genel ortalamada geride bıraktığını gösteriyor.

Python Kurulum ve Kullanım

pip install nixtla

from nixtla import NixtlaClient
import pandas as pd

client = NixtlaClient(api_key="NIXTLA_API_KEY")

df = pd.read_csv("elektrik_tüketimi.csv")
# Sütunlar: unique_id, ds (tarih), y (değer)

# Zero-shot tahmin, eğitim yok, ayar yok
fcst = client.forecast(
    df=df,
    h=24,               # 24 adım ilerisi
    freq="H",           # Saatlik
    level=[80, 95],     # Güven aralıkları
)

print(fcst.head())

Dış değişken ile:

future_exog = pd.DataFrame({
    "unique_id": ["seri_1"] * 24,
    "ds": pd.date_range("2026-08-01", periods=24, freq="H"),
    "sicaklik": [28, 29, 31, 33, 34, 35, 34, 32, 30, 28, 27, 26,
                 25, 25, 26, 28, 30, 31, 32, 31, 30, 29, 28, 27],
})

fcst = client.forecast(
    df=df,
    h=24,
    freq="H",
    X_df=future_exog,   # Dış bağımsız değişken
    level=[90],
)

Anomali tespiti:

anomalies = client.detect_anomalies(df=df, freq="H")
print(anomalies[anomalies["anomaly"] == 1])

TimeGPT Güçlü Yönleri

• Gerçek zero-shot: domain bilgisi veya eğitim verisi gerektirmiyor
• Anıında ölçekleniyor: 1 seri veya 10.000 seri aynı API çağrısı
• Uzun horizon tahmin: 500+ adım
• Conformal prediction ile kalibrasyon güven aralıkları

TimeGPT Zayıf Yönleri

• API tabanlı: offline/air-gapped ortamlar için uygun değil
• Maliyet: yüksek hacimde API maliyeti birikir
• Kara kutu: katsayıları yorumlayamazsınız
• Çok kısa seriler (< 20 gözlem) için ARIMA daha güvenilir

NeuralProphet: Prophet’in Derin Öğrenme Çağı Varisi

NeuralProphet, Stanford ve Nixtla araştırmacılarının geliştirdiği açık kaynaklı kütüphane. Hedef: Prophet’in kullanım kolaylığını PyTorch gücüyle birleştirmek.

Prophet’ten Farkları

Mimari: AR-Net + Mevsimsellik Ayrıştırması

NeuralProphet tahmin bileşenlerini ayrıştırır:

ŷ(t) = trend(t) + mevsimsellik(t) + tatil(t) + AR-net(t) + regresör(t)

AR-Net katmanı, geçmişteki p değerini otomatik ağırlıklarla kullanır. Bu, ARIMA’nın AR bileşeninin öğrenilmiş versiyonu gibi düşünülebilir.

Python Kullanımı

pip install neuralprophet

from neuralprophet import NeuralProphet
import pandas as pd

df = pd.read_csv("gunluk_satis.csv")
df = df.rename(columns={"tarih": "ds", "satis": "y"})

m = NeuralProphet(
    n_forecasts=14,          # 14 gün ilerisi
    n_lags=28,               # 28 günlük AR penceresi
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False,
    loss_func="Huber",       # Outlier'a karşı dayanıklı
    trainer_config={"accelerator": "auto"},  # GPU varsa kullan
)

# Türk tatilleri ekleme
m = m.add_country_holidays("TR")

metrics = m.fit(df, freq="D")
future = m.make_future_dataframe(df, periods=14)
forecast = m.predict(future)
print(forecast[["ds", "yhat1"]].tail(14))

Çoklu seri (global model):

from neuralprophet import NeuralProphet
import pandas as pd

# Farklı mağazaların satış verileri
df_all = pd.read_csv("tum_magazalar.csv")
# Sütunlar: ds, y, ID (mağaza kimliği)

m = NeuralProphet(n_forecasts=7, n_lags=21)
metrics = m.fit(df_all, freq="D", id_col="ID")

future = m.make_future_dataframe(df_all, periods=7, id_col="ID")
forecast = m.predict(future)

Belirsizlik tahmini:

m = NeuralProphet(
    quantiles=[0.1, 0.5, 0.9],  # %80 güven aralığı
    n_forecasts=14,
    n_lags=28,
)
m.fit(df, freq="D")
future = m.make_future_dataframe(df, periods=14)
forecast = m.predict(future)
# forecast["yhat1 10.0%"], forecast["yhat1 90.0%"] alt/üst sınırlar

NeuralProphet Güçlü Yönleri

• Açık kaynak, yerel çalışma, offline desteği
• Mevsimsellik ayrıştırması yorumlanabilir
• GPU hızlandırma ile hızlı eğitim
• Global model: yüzlerce seri tek eğitim

NeuralProphet Zayıf Yönleri

• Eğitim gerektiriyor: zero-shot değil
• Hiperparametre ayarı zaman alıcı (n_lags, hidden_size vb.)
• Çok kısa veride Prophet kadar stabil değil
• Çok uzun horizon (500+) için designed değil

Amazon Chronos: Dil Modeli Mantığıyla Zaman Serisi

Amazon AWS’nin 2024’te açık kaynaklı hale getirdiği Chronos, zaman serisi tahminini NLP görevi olarak yeniden çerçeveler. Fikir radikal: sayıları tokenleştir, dil modeli eğit.

Mimari: Sayıları Token Olarak Öğrenmek

Chronos, klasik metin tokenizasyonunu sayısal değerlere uyarlar:

1. Sayı aralığını bölümlere ayır (örn. 4096 bin)
2. Her değeri en yakın bölüme ata (quantization)
3. Bu token dizisini T5 veya GPT-2 mimarisinde eğit
4. Inference: gelecekteki tokenları örnekle → değerlere geri dönüştür

Bu yaklaşımın güzelliği: zaman serisi tahmin görevi, olasılıksal dil modeli görevi haline geliyor. Belirsizlik, birden fazla örnek çekerek doğal şekilde elde edilir.

Model Boyutları

Python Kullanımı

pip install chronos-forecasting

import torch
import numpy as np
import pandas as pd
from chronos import BaseChronosPipeline

# Model yükle (ilk çalıştırmada indirir ~700MB base için)
pipeline = BaseChronosPipeline.from_pretrained(
    "amazon/chronos-t5-base",
    device_map="auto",   # CUDA varsa GPU, yoksa CPU
    torch_dtype=torch.bfloat16,
)

df = pd.read_csv("satis.csv")
context = torch.tensor(df["satis"].values, dtype=torch.float32)

# Zero-shot tahmin
forecast = pipeline.predict(
    context=context.unsqueeze(0),  # [1, T]
    prediction_length=30,
    num_samples=20,                # Monte Carlo örnek sayısı
)

# Medyan ve yüzdelik aralıklar
low = np.quantile(forecast[0].numpy(), 0.1, axis=0)
median = np.quantile(forecast[0].numpy(), 0.5, axis=0)
high = np.quantile(forecast[0].numpy(), 0.9, axis=0)

print(f"Medyan tahmin (ilk 5): {median[:5]}")
print(f"%80 güven aralığı lower: {low[:5]}")
print(f"%80 güven aralığı upper: {high[:5]}")

Birden fazla seri:

contexts = [
    torch.tensor(df_seri1["y"].values, dtype=torch.float32),
    torch.tensor(df_seri2["y"].values, dtype=torch.float32),
]

forecasts = pipeline.predict(
    context=contexts,
    prediction_length=14,
    num_samples=20,
)

Chronos Güçlü Yönleri

• Tamamen açık kaynak, yerel çalışma
• Olasılıksal: belirsizlik doğal şekilde elde ediliyor
• Sağlam zero-shot: Meta ve OpenAI’ın büyük ölçek kıyaslamalarında güçlü
• Ölçeklenebilir model ailesi: tinytitan’dan huge’a

Chronos Zayıf Yönleri

• GPU bellek: large/huge için önemli VRAM gerektirir
• Dış değişken desteği yok (şimdilik, roadmap’te)
• Hafıza tüketimi CPU modda yüksek
• T5 tabanlı mimari: çok uzun bağlam penceresinde zorlanır

Lag-Llama: Llama Mimarisiyle Zaman Serisi

Lag-Llama, ServiceNow ve Toronto Üniversitesi araştırmacılarının 2024’te yayımladığı ilk decoder-only foundation modeli. Adındaki iki bileşen mimariyi özetler: Lag (gecikmeli özellikler) + Llama (GPT-tarzı causal transformer).

Mimari: Decoder-Only Autoregressive Zaman Serisi

Lag-Llama, metin oluşturmanın aksine sayısal dizileri otoregressif biçimde tahmin eder. “Lag” özellikler: her zaman noktasında geçmişin farklı gecikmelerini (1, 2, 4, 8… adım) otomatik ekler.

Bu, transformer’ın attention mekanizmasına “el yapımı mevsimsellik kodlaması” vermek gibi düşünülebilir: model hem dikkat hem de gecikmeli özellikler üzerinden örüntüleri yakalayabilir.

Python Kullanımı

pip install git+https://github.com/time-series-foundation-models/lag-llama

import torch
import pandas as pd
from gluonts.dataset.pandas import PandasDataset
from gluonts.dataset.split import split
from lag_llama.gluon.estimator import LagLlamaEstimator

# GluonTS formatına dönüştür
df = pd.read_csv("satis.csv", index_col="tarih", parse_dates=True)
dataset = PandasDataset(dict(df))

# Zero-shot tahmin (fine-tune olmadan)
estimator = LagLlamaEstimator(
    ckpt_path="lag-llama.ckpt",    # Önceden indirilen checkpoint
    prediction_length=24,
    context_length=32,
    num_parallel_samples=20,
    device=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
)

lightning_module = estimator.create_lightning_module()
predictor = estimator.create_predictor(
    transformation=estimator.create_transformation(),
    lightning_module=lightning_module,
)

forecasts = list(predictor.predict(dataset))
print(f"Örnek sayısı: {forecasts[0].samples.shape}")
# (num_samples, prediction_length)

Fine-tuning ile (az veri):

estimator_ft = LagLlamaEstimator(
    ckpt_path="lag-llama.ckpt",
    prediction_length=24,
    context_length=32,
    num_parallel_samples=20,
    nonnegative_pred_samples=True,  # Negatif tahmin olmasın
    lr=5e-4,
    max_epochs=50,                   # Az epoch fine-tune için yeterli
)

# Fine-tune
predictor_ft = estimator_ft.train(dataset)
forecasts_ft = list(predictor_ft.predict(dataset))

Lag-Llama Güçlü Yönleri

• Decoder-only: uzun bağlam penceresini verimli kullanır
• Fine-tuning uyumlu: az örnekle domain adaptasyonu
• Açık ağırlıklar (Llama-2 lisansı)
• Olasılıksal: güven aralıkları Monte Carlo ile

Lag-Llama Zayıf Yönleri

• Ekosistem henüz olgunlaşmadı: GluonTS bağımlılığı zorunlu
• Dış değişken desteği sınırlı
• Checkpoint boyutu (ckpt download) ilk kurulumda yavaş
• Chronos’a kıyasla daha az kıyaslama verisi mevcut

Kapsamlı Karşılaştırma Tablosu

*Chronos dış değişken roadmap’te

Karar Matrisi: Projenize Göre Hangi Araç?

Senaryo 1: Hızlı prototip, veri bilimi ekibi yok

Seçim: TimeGPT

# 10 satır kod, sıfır alan bilgisi
from nixtla import NixtlaClient
client = NixtlaClient(api_key="API_KEY")
fcst = client.forecast(df=df, h=30, freq="D")

Haftalarca ARIMA parametre optimizasyonu yerine saatler içinde sonuç. Proof-of-concept aşamasında idealdir.

Senaryo 2: Üretim ortamı, offline, yorumlanabilirlik kritik

Seçim: ARIMA (az seri) veya NeuralProphet (çok seri)

Finans düzenleyicisi, sağlık denetçisi veya güvenlik gereksinimleri nedeniyle kara kutu tolere edilemiyorsa, yorumlanabilir modeller zorunlu. ARIMA katsayıları, NeuralProphet mevsimsellik bileşenleri açıklanabilir.

Senaryo 3: Binlerce seri, toplu tahmin, AWS ekosistemi

Seçim: Amazon Chronos

# SageMaker entegrasyonu
from chronos import BaseChronosPipeline
# AWS S3'ten veri, SageMaker endpoint'te çalışma

Chronos, AWS’nin kendi SageMaker JumpStart kataloğunda sunuluyor. AWS altyapısındaysanız entegrasyon maliyeti sıfır.

Senaryo 4: Yüksek frekanslı veri, GPU mevcut, açık kaynak zorunlu

Seçim: Chronos (GPU) veya NeuralProphet (GPU)

Saatlik/dakikalık enerji, IoT sensör verileri için GPU hızlanmalı açık kaynak seçenekler.

Senaryo 5: Domain verisiyle ince ayar, araştırma veya özel sektör

Seçim: Lag-Llama (fine-tune) veya NeuralProphet

Özel bir domain veriniz varsa ve zero-shot performansı yeterli değilse, Lag-Llama fine-tuning ile domain adaptasyonu güçlü. Akademik çalışmalar için ideal.

Senaryo 6: Tatiller önemli, iş analistleri de kullanacak

Seçim: Prophet veya NeuralProphet

Türk bayramları, dini tatiller ve özel kampanya günleri modelinize kritik etki yapıyorsa, tatil entegrasyonu en kolay Prophet ve NeuralProphet’te.

Kıyaslama: Gerçek Dünya Performansı

Akademik kıyaslamalarda dikkat edilmesi gereken bir nokta: hangi veri seti, hangi metrik, hangi horizon.

Nixtla’nın TimeGPT Kıyaslaması (2023)

• 300+ veri seti, sMAPE metriği
• TimeGPT zero-shot; ARIMA, ETS, Theta gibi rakipler tam eğitim
• Sonuç: TimeGPT ortalamada klasik modelleri geride bırakıyor, ancak fark veri setine göre değişken

Amazon Chronos Kıyaslaması (2024)

• 42 veri seti, WQL (Weighted Quantile Loss) ve CRPS metrikleri
• Chronos (base, 200M), çok sayıda özel eğitimli modeli geride bırakıyor
• En güçlü olduğu alan: çeşitli ve heterojen veri setleri

Lag-Llama Kıyaslaması (2024)

• GluonTS test seti üzerinde
• Lag-Llama zero-shot, ARIMA ve ETS’yi geçiyor
• Fine-tune edildiğinde: domain-specific modellere yaklaşıyor

Pratik Önerim

Akademik kıyaslamalara takılmayın. Kendi verinizle, kendi metriğinizle, kendi horizonunuzla test yapın. Küçük bir holdout seti üzerinde 30 dakikalık A/B testi, herhangi bir makalede bulacağınız numaradan değerlidir.

Üretim Notları 2026

TimeGPT Üretim Mimari

import time
from nixtla import NixtlaClient
from tenacity import retry, stop_after_attempt, wait_exponential

client = NixtlaClient(api_key="API_KEY")

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4))
def tahmin_al(df, h=30):
    return client.forecast(df=df, h=h, freq="D")

# Rate limit yönetimi: büyük batch'leri parçalara böl
def toplu_tahmin(df_dict, h=30, batch_size=100):
    sonuclar = {}
    seriler = list(df_dict.keys())
    
    for i in range(0, len(seriler), batch_size):
        batch = seriler[i:i+batch_size]
        df_batch = pd.concat([df_dict[s] for s in batch])
        df_batch["unique_id"] = [s for s in batch 
                                  for _ in range(len(df_dict[s]))]
        fcst = tahmin_al(df_batch, h=h)
        for seri_id in batch:
            sonuclar[seri_id] = fcst[fcst["unique_id"] == seri_id]
        time.sleep(0.5)  # Rate limit buffer
    
    return sonuclar

Chronos Üretim: Bellek Yönetimi

import torch
from chronos import BaseChronosPipeline

# Bellek açısından verimli kullanım
pipeline = BaseChronosPipeline.from_pretrained(
    "amazon/chronos-t5-base",
    device_map="auto",
    torch_dtype=torch.bfloat16,  # float32 yerine bfloat16: ~%50 bellek
)

# Büyük batch için torch.no_grad()
with torch.no_grad():
    forecasts = pipeline.predict(contexts, prediction_length=30)

# GPU belleği temizle
torch.cuda.empty_cache()

Model Seçimi Pipeline’a Nasıl Entegre Edilir?

class ZamanSeriisiTahminPipeline:
    """Dinamik model seçimli tahmin pipeline'ı."""
    
    def __init__(self, tercih="auto"):
        self.tercih = tercih
    
    def tahmin_et(self, df, h):
        n_gozlem = len(df)
        n_seri = df["unique_id"].nunique() if "unique_id" in df.columns else 1
        
        if self.tercih == "auto":
            if n_gozlem < 50:
                return self._arima_tahmin(df, h)
            elif n_seri > 1000:
                return self._chronos_tahmin(df, h)
            else:
                return self._timegpt_tahmin(df, h)
        
        # Manuel seçim
        return getattr(self, f"_{self.tercih}_tahmin")(df, h)

Sık Karşılaşılan Hatalar

1. Mevsimsellik dönemini yanlış belirtmek

# Yanlış: günlük veri, aylık mevsimsellik istiyorsunuz
model = ARIMA(y, order=(2,1,2), seasonal_order=(1,1,1,12))
# 12, aylık mevsimsellik için → günlük veride 12 AY değil 12 GÜN anlamına gelir

# Doğru: günlük veri, haftalık mevsimsellik
model = ARIMA(y, order=(2,1,2), seasonal_order=(1,1,1,7))

2. Foundation modelde çok kısa bağlam

# Chronos için bağlam uzunluğu en az prediction_length * 2 olsun
context = torch.tensor(son_14_gun, dtype=torch.float32)  # 14 gün
forecasts = pipeline.predict(context.unsqueeze(0), prediction_length=30)
# Problem: 14 günlük bağlamla 30 günlük tahmin, güvenilirlik düşük

# Daha iyi: en az 60-90 gün bağlam
context = torch.tensor(son_90_gun, dtype=torch.float32)

3. Ölçek sorunları

# Foundation modeller ölçeğe duyarlı olabilir
# Normalize et, tahmin yap, geri ölçekle

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
y_scaled = scaler.fit_transform(df[["y"]])

# ... tahmin ...

y_pred_original = scaler.inverse_transform(forecast)

4. Veri sızıntısı (data leakage)

# Yanlış: tüm veriyle fit, sonra aynı veriden test
model.fit(df)
test_pred = model.predict(df.index)  # Bu in-sample, gerçek test değil!

# Doğru: zaman tabanlı bölme
train = df[df["ds"] < "2026-01-01"]
test = df[df["ds"] >= "2026-01-01"]
model.fit(train)
test_pred = model.predict(periods=len(test))

Hangi Metrik Kullanılmalı?

Ortalama Mutlak Hata (MAE) her zaman yeterli değildir. Senaryoya göre:

from sklearn.metrics import mean_absolute_error
import numpy as np

def smape(y_true, y_pred):
    return 100 * np.mean(
        2 * np.abs(y_pred - y_true) / (np.abs(y_true) + np.abs(y_pred))
    )

mae = mean_absolute_error(y_test, y_pred)
smape_val = smape(y_test, y_pred)
print(f"MAE: {mae:.2f}, sMAPE: {smape_val:.2f}%")

2026 Ekosistem Özeti ve Tavsiyem

Zaman serisi tahmini artık “tek araç” sorunu değil. Üretimde şu çerçeveyi öneriyorum:

1. Başlangıç noktası: TimeGPT zero-shot ile hızlı kıyaslama, ne kadar iyileştirilebileceğinizi görün.
2. Referans çizgisi: ARIMA veya Prophet, anlaşılır, savunulabilir, yorumlanabilir bir zemin.
3. Açık kaynak foundation: Chronos (AWS ekosistemi) veya Lag-Llama (ince ayar gerekiyorsa), API bağımlılığı olmadan üretim.
4. Hibrit Prophet varisi: NeuralProphet, tatiller kritik, mevsimsellik yorumlanabilirliği önemliyse.

Foundation modellerin gücü tartışmasız artıyor. Ancak 2026’da bile ARIMA ve Prophet’in öldüğünü söylemek erken: yorumlanabilirlik, düzenleme gereksinimleri ve çok kısa seri senaryolarında klasik araçlar hâlâ rekabetçi.

Kaynaklar ve İleri Okuma

• Nixtla TimeGPT teknik raporu, Garza ve ark. (2023)
• Amazon Chronos makalesi, Ansari ve ark. (2024)
• Lag-Llama makalesi, Rasul ve ark. (2024)
• NeuralProphet GitHub
• GluonTS kütüphanesi, Chronos ve Lag-Llama ekosistemi
• Nixtla StatsForecast, Hızlı klasik model alternatifleri

Bu makale, zaman serisi tahmini alanında Türkçe kaynak boşluğunu doldurmak amacıyla yazılmıştır. Araçlar hızlı gelişiyor; güncel sürüm notları için her kütüphanenin GitHub sayfasını takip edin.