Derin Öğrenme ile Zaman Serisi Tahminlemesi
İncelemede geçer not alan tahminleme: Naif temel modellerle başlayın, sızıntısız gecikme özellikleri oluşturun, PyTorch'ta bir LSTM eğitin ve ileriye dönük doğrulama ile değerlendirin.

Bir LSTM ile oluşturduğum talep tahmini, incelemede mükemmel görünüyordu: düşük bir yüzde hata ve gerçek değerlere yapışan bir tahmin çizgisi. Sonra bir meslektaşım iki seriyi üst üste bindirdi ve yakınlaştırdı. Tahmin, gerçek eğrinin bir adım kaydırılmış haliydi. Ağ, gördüğü son değeri tekrarlamayı öğrenmişti, ki bu tam olarak tek satırlık bir temel modelin yaptığı şeydi ve buna ulaşmak bize iki haftalık eğitim deneylerine mal olmuştu.
Derin öğrenme, zaman serisi tahminlerini iyileştirebilir, ancak yalnızca dürüst bir değerlendirme altında basit alternatifleri yendiğini kanıtlarsanız. Bu yazı, bunu yapmak için kullandığım iş akışını ve kendi serilerinizde çalıştırabileceğiniz kodu içerir. Önce sinir ağı temellerine ihtiyacınız varsa, Derin Öğrenme Temelleri ile başlayın.
Önemli Çıkarımlar
- Her zaman önce naif bir tahmin ve mevsimsel-naif bir tahmin hesaplayın. Modeliniz bunları yenemiyorsa, faydalı hiçbir şey öğrenmemiştir.
- Hiçbir özelliğin tahmin ettiği değeri görmemesi için
shift(1)kullanarak gecikme ve yuvarlanan (rolling) özellikler oluşturun. - Ölçekleyicileri yalnızca eğitim katmanına (training fold) uygulayın ve rastgele bölmeler yerine ileriye dönük bölmelerle değerlendirin.
- Sınırlı geçmişe sahip tek bir seri için, gecikme özellikleri üzerinde gradyan artırma (gradient boosting) genellikle bir LSTM kadar iyidir ve çalıştırması çok daha ucuzdur.
- Derin modeller, birçok ilişkili seri, uzun geçmişler ve zengin harici sinyaller üzerinde maliyetlerini hak eder.
Oluşturmam gereken ilk model nedir?
Dakikalar içinde yazılmış iki temel model. Naif tahmin, bir sonraki değerin son değere eşit olacağını öngörür. Mevsimsel-naif tahmin ise, bir sezon önceki değere eşit olacağını öngörür; örneğin dün aynı saat veya geçen hafta aynı hafta içi. Birçok üretim sistemi sessizce bunları kullanır ve bunlar çıtayı belirler. Klasik modeller bir sonraki adımdır: ARIMA, tek bir seri için sağlam, yorumlanabilir bir temel modeldir ve güçlü takvim etkileriniz olduğunda Prophet ile hızlıca prototip oluşturulabilir.
Neyle savaştığınızı bilin. Bir seri, trend artı mevsimsellik artı gürültüdür ve zor kısımlar durağan olmama (non-stationarity), çoklu mevsimsellikler, eksik değerler ve desenin kendisinin değiştiği kavram kaymasıdır (concept drift). Herhangi bir modelleme yapmadan önce seriyi ve otokorelasyonunu çizin.
Geleceği sızdırmadan özellikleri nasıl mühendislik ederim?
Gecikme özellikleri, yuvarlanan istatistikler ve takvim alanları sinyalin çoğunu kapsar. Kaçınılması gereken sızıntı, mevcut değeri içeren ve modele cevabı veren bir kayan penceredir:
import pandas as pd
def add_features(df: pd.DataFrame, target: str = "demand") -> pd.DataFrame:
out = df.copy()
for lag in (1, 24, 168): # previous step, same hour yesterday, same hour last week
out[f"lag_{lag}"] = out[target].shift(lag)
# shift(1) before rolling so the window never includes the value being predicted
out["roll_mean_24"] = out[target].shift(1).rolling(24).mean()
out["roll_std_24"] = out[target].shift(1).rolling(24).std()
out["hour"] = out.index.hour
out["dow"] = out.index.dayofweek
return out.dropna()
Çerçevenin bir DatetimeIndex'e ihtiyacı vardır. Tahmin zamanında değerlerini bileceğiniz tatilleri, promosyonları, hava durumunu veya fiyatları harici özellikler olarak ekleyin; yalnızca sonradan öğrendiğiniz bir özellik bir sızıntıdır. Bu sütunlarla birkaç satırda gradyan artırma (LightGBM, XGBoost) eğitebilirsiniz ve bu, herhangi bir sinir ağı denemeden önce denediğim modeldir.
PyTorch'ta bir LSTM tahminleyicisi nasıl eğitilir?
LSTM'ler ve GRU'lar, geçmiş değerlerin bir penceresini okur ve bir sonrakini tahmin eder. Aşağıdaki kod, bir seriyi pencerelere dönüştürür, küçük bir model tanımlar ve onu bir L1 kaybı ile eğitir:
import numpy as np
import torch
from torch import nn
def make_windows(series: np.ndarray, lookback: int):
X, y = [], []
for i in range(len(series) - lookback):
X.append(series[i : i + lookback])
y.append(series[i + lookback])
return np.array(X, dtype=np.float32)[..., None], np.array(y, dtype=np.float32)
class LSTMForecaster(nn.Module):
def __init__(self, hidden: int = 32):
super().__init__()
self.lstm = nn.LSTM(input_size=1, hidden_size=hidden, batch_first=True)
self.head = nn.Linear(hidden, 1)
def forward(self, x):
out, _ = self.lstm(x)
return self.head(out[:, -1]).squeeze(-1)
def fit(model, X, y, epochs: int = 20, lr: float = 1e-3):
X_t, y_t = torch.from_numpy(X), torch.from_numpy(y)
opt = torch.optim.Adam(model.parameters(), lr=lr)
loss_fn = nn.L1Loss()
for _ in range(epochs):
model.train()
for idx in torch.randperm(len(X_t)).split(64):
opt.zero_grad()
loss = loss_fn(model(X_t[idx]), y_t[idx])
loss.backward()
opt.step()
return model
Zamansal evrişimli ağlar (Temporal convolutional networks), tekrarlamayı paralel olarak eğitilen ve genellikle daha hızlı olan genişletilmiş evrişimlerle değiştirir. Transformer tabanlı modeller, uzun menzilli bağımlılıkları yakalar ve birçok seriye sahip büyük veri kümelerinde parlar. Hepsi aynı pencereli girdiyi tüketir, bu nedenle aşağıdaki değerlendirme kodu hepsi için çalışır.
Bir tahmini dürüstçe nasıl değerlendiririm?
Rastgele eğitim ve test bölmeleri, modelin geleceğe göz atmasına izin verir, bu nedenle zaman serileri için yanlıştır. İleriye dönük doğrulama kullanın: geçmiş üzerinde eğitin, takip eden blok üzerinde test edin, sonra ileri kaydırın. Yalnızca eğitim katmanından (training fold) gelen istatistiklerle ölçeklendirin ve aynı döngüde her iki temel modelle karşılaştırın:
from sklearn.model_selection import TimeSeriesSplit
LOOKBACK = 48 # values: a 1-D float array of the series, hourly data in this example
for fold, (tr, te) in enumerate(TimeSeriesSplit(n_splits=3, test_size=168).split(values)):
mu, sigma = values[tr].mean(), values[tr].std() # statistics from the training fold only
scaled = (values - mu) / sigma
X_tr, y_tr = make_windows(scaled[tr], LOOKBACK)
# test windows may look back into the training fold, never forward
X_te, y_te = make_windows(scaled[te[0] - LOOKBACK : te[-1] + 1], LOOKBACK)
model = fit(LSTMForecaster(), X_tr, y_tr)
model.eval()
with torch.no_grad():
pred = model(torch.from_numpy(X_te)).numpy()
naive = X_te[:, -1, 0] # last observed value
seasonal = X_te[:, -24, 0] # same hour yesterday
mae = lambda p: float(np.abs(y_te - p).mean())
print(fold, f"naive {mae(naive):.3f} seasonal {mae(seasonal):.3f} lstm {mae(pred):.3f}")
MAE ve RMSE'yi paydaşlarınızın anlayacağı birimlerde raporlayın. MAPE popülerdir ancak gerçek değerler sıfıra yakın olduğunda patlar. MASE, hatayı naif bir tahminin hatasına böler, bu nedenle 1'in altındaki bir değer, temel modeli yendiğiniz anlamına gelir ki bu aslında önemsediğiniz sorudur. LSTM sütunu katmanlar arasında diğerlerinden açıkça daha düşük değilse, ağı ayarlamayı bırakın ve özellikleri iyileştirin.
Diğer mimariler ve topluluk öğrenme (ensembles) ne zaman yardımcı olur?
Birkaç bin noktalı tek bir seride, iyi tasarlanmış gecikme özelliklerini gradyan artırma (gradient boosting) ile kullanan derin bir modelin nadiren daha iyi performans gösterdiğini görüyorum ve artırılmış modelin açıklanması ve yeniden eğitilmesi daha kolaydır. Derin modeller, binlerce ilişkili seri üzerinde tek bir global model eğittiğinizde, uzun geçmişleriniz olduğunda veya metin, görüntüler veya birçok harici sinyali birleştirdiğinizde karşılığını vermeye başlar. Topluluk öğrenme modelleri (Ensembles) güvenilirdir: istatistiksel bir modelin, artırılmış bir modelin ve bir sinir ağının ortalaması genellikle her birini tek başına yener, çünkü hataları farklılık gösterir. Ne dağıtırsanız dağıtın, kaymayı (drift) kaçınılmaz kabul edin ve izleyin; pipeline tarafı Üretim ML Pipeline'ları Oluşturma bölümünde, veri kontrolleri ise Veri Mühendisliği En İyi Uygulamaları bölümünde ele alınmıştır.
Bu hafta ne yapmalıyım?
Halihazırda çalıştırdığınız bir tahmini alın. Son dört hafta boyunca naif ve mevsimsel-naif hataları ileriye dönük katmanlarla hesaplayın ve üç sayıyı mevcut modelinizin hatasının yanına tek bir tabloda koyun. Model açıkça kazanmazsa, bir sonraki projenizi buldunuz demektir ve bu, başka bir ağ eğitmeye göre daha ucuz bir projedir.
Uğur Kaval
Modern teknolojilerle yenilikçi çözümler geliştirmede uzmanlaşmış AI/ML Mühendisi & Full Stack Geliştirici. Otomasyon, makine öğrenmesi ve web geliştirme tutkunu.


