Zaman Serilerinde İteratif (Yinelemeli), Çok Adımlı Tahmin Yöntemi

Bu yazı, zaman serisi tahminlerinde, iteratif (yinelemeli) çok adımlı yöntemin uygulamasını anlatan, bir eğitim dökümanı olarak tasarlanmıştır. (Recersive Multi-step Forecasting for Time Series)

Matematikte iterasyon, genellikle bir işlemin noktasal ya da fonksiyonel olarak sabit bir sonuca veya çözüme yaklaşana kadar yinelenmesidir (tekrarlanmasıdır). Programlamada iterasyon döngüler (loops) kullanılarak gerçekleştirilir.

Kodlamada iterasyon, döngülerle (loops) oluşturuluyor.

Belirli bir değişken için farklı zaman periyotlarında (günlük, haftalık, aylık, yıllık gibi) toplanan verilere “zaman serisi” verileri denir. Zaman serileriyle çalışırken yaygın olarak, gelecekteki bir aralığın (t+1, …, t+n) veya zaman içindeki uzak bir noktanın (t+n) tahmin edilmesi amaçlanır. Örneğin ekonometride zaman serisi kullanılarak bir hisse senedinin açılışta veya uzun vadede fiyatı öngörülür.

Modellemede, ileriyi -t(n)- tahmin etmek için, önceki değerlere -t(n-1)- ihtiyaç duyulur. O nedenle, iteratif çok adımlı tahmin yönteminde, zaman serisi periyoduna bağlı olarak (günlük, aylık…), her yeni tahminin bir önceki tahmine dayandığı yinelemeli bir süreç uygulanır.

Basitçe anlamak için elimizde bir kitabın son 12 aya ait fiyat listesinin olduğunu varsayalım. Oluşturduğumuz model ile kitabın “bir sonraki ay” (ay+1) fiyatı tahmin ediliyor. Modeli iteratif olarak kurguladığımızda ise, ay+1 (gelecek ay) tahmini, mevcut 12 aylık listenin sonuna ekleniyor. Liste 13 elemanlı oluyor. 12 fiyat için kurgulanan modelde, listedeki ilk fiyat, yeni tahminlemede model dahil edilmiyor. Yani yeni tahmin, listedeki güncel son 12 değeri alarak, bu kez ay+2 ‘yi (1 ay sonrayı) tahminliyor ve listenin sonuna eklenerek, bir sonraki tahmin için girdilerde yerini alıyor. Tekrar son 12 ay alınıp, ay+3 tahmin edilip listeye eklenerek, ay+4 tahminine girdi oluşturuyor ve böylece gelecek 24 ay tahmini için, işlem 24 kere tekrarlanıyor. Bu işlem, Yinelemeli Çok Adımlı Tahmin (Recursive / Iterative Multi-step Forecasting) olarak adlandırılıyor.

Özyinelemeli (iteratif) Çok Adımlı Tahmin İlerleyişi

Her iterasyon, daha önceki iterasyonların başarı ve başarısızlıklarından etkilenir. İteratif yöntem ilerledikçe, hatalı tahminler de girdiye eklendiği için tahmin hataları (hata birikimi) artabilir. Bu önemli bir dezavantaj oluşturur.

1) Neden iteratif yöntem tercih edilir?

• Basit ve yaygındır. Tek adım sonrasını (gelecek ay, yıl gibi) tahmin için eğtilen model, iterasyon ile çok adım tahmin için (gelecek aylar, yıllar vs.) kullanılabilir.
• Eğitim verisi ve model daha basittir ve dolayısıyla ekonomiktir. Çünkü çok-adımlı ayrı bir model eğitmek yerine tek model yeterlidir.
• Eğer model, bir sonraki adım tahminini yapmayı çok iyi öğrenmişse, kısa-orta vadede kuvvetli iteratif tahminlerde bulunabilir.
• Eğer eğitim seti küçükse, çok-adımlı doğrudan modeller için yeterli olmayabilir. O nedenle iteratif yöntem tercih edilir.

2) İteratif Yerine Alternatif Yöntemler :

• Direct (doğrudan): Her hedef adım için ayrı bir model eğitilir (t+1 için bir model, t+2 için başka model…). Dezavantaj: daha çok model, daha çok veri, daha çok enerji gerektirir.
• Multi-output: Tek bir model, aynı anda çoklu adımları çıktı olarak verir (ör. model çıktısı bir vektör: [t+1, t+2, …, t+24]).
• Sequence-to-sequence modeller: LSTM seq2seq, Transformer tabanlı modeller doğrudan çok adımlı tahmin yapabilir.
• Bazı hibrid yöntemler: iteratif + düzeltme, ensembler’lar vb.

Which side?

3) İteratif yöntemin tercih edildiği durumlar

a) Hangi Durum: Eğitim verisi azsa; modelin tek-adım performansı iyiyse; veya çoklu adım için ayrı modeller kurmak pratik değilse.

b) Hangi Veri Tipi: Düzenli zaman aralıklı veriler (aylık/günlük/saatlik gibi.). Özellikle kısa/orta vadeli tahminler için kullanışlıdır. Mevsimsellik veya trend varsa ve tek adım öğrenilebiliyorsa tercih edilir.

c) Hangi Modelleme: Basit regresyon, AR modelleri, veya tek-adım öğrenebilen makine öğrenmesi modelleri ile kullanışlı.

d) Hangi Uygulamalar: Finans (kısa vadeli fiyat tahminleri), enerji talep tahmini (kısa dönem), envanter tahmini, sensör verisi tahmini, vb.

4) İterasyon Mantığı :

1. Tercih edilen model eğitilirken, girdi olarak geçmiş son k (lags/adım) değeri (örneğin son 12 ay) kullanılır. Çıktı olarak ise bir adım sonraki (t+1) değer tahmin edilir. Örneğin 13. ayın (12+1) değeri gibi.
2. Diğer bir deyişle, çok adımlı tahmin için başlangıç olarak son k (lags/adım) değeri alınır. (Örneğin son 12 ay).
3. Model kullanılarak bir sonraki ay (t+1) tahmin edilir ve kaydedilir.
4. Geçmiş listesindeki en eski değer atılarak, bu yeni tahmin değeri eklenir. Dolayısıyla örneğimize göre, liste hep 12 elemanlı olarak kalır.
5. Listedeki yeni değerlerle tekrar tahmin yapılır(t+2). İstenen adım sayısına ulaşılana kadar 3. adım ve 4. adım tekrarlanır.

Genel Sonuç / Öneriler

• İteratif (one-step-ahead) yöntem basit, anlaşılır, ve küçük veri için uygun. Dezavantajı ise uzun vadede hata birikimi riskidir.
• Eğer uzun vadeli tahmin gerekiyorsa, direct veya seq2seq / multi-output yaklaşımları da terecih edilebilir.
• Verinin doğası (mevsimsellik, trend, ani değişimler), veri miktarı ve hata toleransı her zaman göz önünde bulundurulmalıdır.

UYGULAMALI ANLATIMI

Daha anlaşılır olmak için bir uygulama örneği le devam edilecektir.
Bu amaçla öncelikle, SENTETİK, basit bir aylık fiyat serisi oluşturularak, bir sonraki ayı tahmin eden (one-step-ahead), 12 adım gecikmeli (lag 1..12) özellikler girdi olarak kullanılıp model eğitildi. Basit ve öğretici olması için Lineer Regresyon modeli tercih edildi. Test performansı hesaplanıp ardından gelecek 24 ay için, iteratif çok adımlı olarak tahmin modeli oluşturuldu. Yani her adımda bir ay tahmin edilip bu tahmin sonraki adımın girdisi olarak tekrar kullanıldı.

Çıktının (yapılan tahminin), girdi olarak tekrar sisteme sokulması için, Seed (başlangıç) listesinde son 12 değer tutulmuştur. Her tahmin, bu seed listesine eklenmiş, sonraki adımda modelin beklediği lag sırasına göre (t−1, t−2, …) bu son tahmin de, yeni tahmin hesaplanmasına dahil edilmiştir. Böylece model “gerçek yerine modelin kendi tahminini” görerek, sonraki adımı hesaplamıştır.

Kodlamada: seed = last_observed.copy() ile son 12 gözlem alındı.

Döngüde: x = [t-1, t-2, …, t-12] oluşturuldu, model.predict ile tahmin alındı, seed.append(pred) ile tahmin geri eklendi.

Kod ve kodlamaya ait açıklamar, aşağıda bölüm bölüm anlatılmıştır:

1) Sentetik veri üretimi

# ———- 1) Sentetik veri üretimi ———-
import numpy as np
import pandas as pd

np.random.seed(42)
periods = 72 # kaç aylık veri üretileceği (72 = 6 yıl)
dates = pd.date_range(start="2019-01-01", periods=periods, freq="MS") # 2019-01-01'den başlayan72 aylık tarih endeksi

trend = 0.5 * np.arange(periods) # basit lineer trend
seasonal = 10 * np.sin(2 * np.pi * np.arange(periods) / 12) # yıllık (12 aylık) mevsimsellik
noise = np.random.normal(scale=3.0, size=periods) # rastgele gürültü (normal dağılım)
base = 50
prices = base + trend + seasonal + noise
series = pd.Series(prices, index=dates, name="price")

• Bu Kısımda Amaç: örnek göstermek için gerçek dünyaya benzeyen ama kontrol edilebilir bir zaman serisi (fiyat) üretmek.
• np.random.seed(42) — rastgele sayı üreticisinin başlatıcısı (seed). Aynı seed ile çalıştırınca sonuçlar tekrarlanabilir olur. Deneylerin tutarlılığı için kullanılır.
• periods = 72 — toplam gözlem sayısı (ay cinsinden). Bu örnekte 6 yıl * 12 ay = 72.
• pd.date_range(start="2019-01-01", periods=periods, freq="MS") — baştan ay başlangıçlarını (Month Start) veren tarih dizisi oluşturur. Bu diziyi series’in index’i yapıyoruz ki zaman ekseni doğru olsun.
• np.arange(periods) — 0,1,2,…,periods-1 şeklinde ardışık tamsayı dizisi üretir; trend ve mevsim fonksiyonlarında zaman referansı olarak kullanılır.
• trend = 0.5 * np.arange(periods) — her adımda 0.5 birim artan doğrusal bir trend ekler; böylece zamanla artan fiyat eğilimi oluşturulur.
• seasonal = 10 * np.sin(2 * np.pi * np.arange(periods) / 12) — 12 aylık döngüde sinüs ile mevsimsel dalga üretir (amplitude 10). 2*np.pi/12 bir yıllık periyot sağlar.
• noise = np.random.normal(scale=3.0, size=periods) — normal dağılımdan rastgele gürültü; gerçek verideki rastgelelik/gürültüyü taklit eder.
• Dikkat! trend, seasonal ve noise’a ait çıktıların veri tipi “array’”dir ve her bir array periods ile belirlendiği gibi 72 elemanlıdır.
• base = 50 ve prices = base + trend + seasonal + noise ile nihai fiyat dizisini oluşturuyoruz.
• pd.Series(…, index=dates, name="price") — pandas Series, zaman etiketleriyle veriyi saklamak için kullanışlıdır (zaman serisi işlemleri için idealdir).

2) Lag (gecikme) özellikleri oluşturma

# ———- 2) Lag özellikleri (1..12) ———-
max_lag = 12
df = pd.DataFrame(series)
for lag in range(1, max_lag + 1):
df[f"lag_{lag}"] = df["price"].shift(lag)
df_clean = df.dropna().copy() # ilk 'max_lag' satırı NaN olur; onları çıkarıyoruz

• Amaç: geçmiş değerleri (lag) model girdisi olarak hazırlamak. Autoregresif (AR) tarzı modeller genelde önceki k adet (lag/adım) gözlemi kullanır.
• max_lag = 12 — modelin bir tahmin için kaç geçmiş değeri kullanacağı (burada 12 ay).
• df = pd.DataFrame(series) — Series'i DataFrame'e çeviriyoruz, böylece hem orijinal price hem de lag_* sütunları bir arada olur.
• Döngüde df["price"].shift(lag) — pandas shift fonksiyonu sütunu yukarı kaydırır; örn. lag_1 t−1, lag_2 t−2 değerini verir. Bu, supervised learning (gözetimli öğrenme) için geçmiş değerler → hedef (next value) şeklinde özellik yaratır.
• df.dropna() — ilk max_lag satırın bazı lag_* değerleri NaN olur (çünkü geriye dönük değer yok), bunları çıkarıyoruz. copy() performans uyarılarını engeller ve bağımsız kopya oluşturur.

3) Train / Test split (eğitim ve test verisi ayrımı)

# ———- 3) Train / Test split ———-
train_rows_after_dropna = 48 # dropna sonrası kaç satırı train olarak kullanacağımız (örneğin)
total_after = df_clean.shape[0]

# basit güvenlik kontrolü
if train_rows_after_dropna + 12 > total_after:
raise ValueError("train_rows_after_dropna + 12 (test) exceed available rows after dropna. Adjust periods or train size.")

train = df_clean.iloc[:train_rows_after_dropna]
test = df_clean.iloc[train_rows_after_dropna:]

X_train = train[[f"lag_{i}" for i in range(1, max_lag + 1)]].values
y_train = train["price"].values
X_test = test[[f"lag_{i}" for i in range(1, max_lag + 1)]].values
y_test = test["price"].values
test_index = test.index

• Bu Adımda Amaç: modeli eğitirken geçmiş verileri (train) kullanmak ve eğitilmiş modelin performansını daha önce görmediği veriler (test) üzerinde ölçmek.
• train_rows_after_dropna = 48 — dropna işleminden sonra ilk 48 satırı eğitim, sonraki 12 satırı test olarak kullanıyoruz. Bu, zaman serisine özgü bir ayrıştırmadır (zamana göre sıralı split).
• df_clean.shape[0] — dropna sonrası toplam satır sayısını verir; güvenlik kontrolü ile test ve train boyutlarının uygun olduğundan emin oluyoruz.
• train = df_clean.iloc[:train_rows_after_dropna] — sıralı olarak ilk N satırı alıyoruz (time series'te random shuffle yapmayız çünkü zaman bağımlılığı var).
• X_train = train[[f"lag_{i}" …]] — modelin girdi matrisi; .values ile NumPy dizisine çeviriyoruz çünkü sklearn NumPy bekler.
• y_train = train["price"].values — hedef değişken (bir sonraki adımın fiyatı), yine NumPy dizisi.
• test_index = test.index — sonuçları sunarken tarihleri kullanmak için saklıyoruz.

4) Model eğitimi (Linear Regression — autoregresif)

# ———- 4) Model eğitimi (Linear Regression – autoregresif) ———-
from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)

• Bu Adımda Amaç: geçmiş lag değerleri ile bir sonraki değeri (one-step-ahead) öğrenen basit doğrusal model eğitmek.
• Basit, yorumlanabilir ve hızlı oması nedeniyle; eğitim amaçlı bu demoda Lineer Regresyon (LinearRegression) tercih edilmiştir. Gerçek veri ve daha karmaşık ilişkiler için ağaç tabanlı veya sinir ağı modelleri denenebilir.
• from sklearn.linear_model import LinearRegression — scikit-learn kütüphanesinden doğrusal regresyon sınıfını getirir.
• model = LinearRegression() — model nesnesi oluşturulur. Bu model girdi (özellikler) ile hedef arasında lineer ilişki varsayar: y ≈ w0 + w1*x1 + ….
• model.fit(X_train, y_train) — eğitim verisiyle model parametreleri öğrenilir (en küçük kareler yöntemiyle katsayılar hesaplanır).

5) One-step-ahead test tahminleri (gerçek lagler ile)

# ———- 5) One-step-ahead test tahminleri (gerçek lag değerleri ile) ———-
y_pred_test = model.predict(X_test)

• Amaç: modelin, “bir sonraki adımı” doğru tahmin edip etmediğini test verisi üzerinde ölçmek.
• model.predict(X_test) — test setindeki her bir satır için modelin öngördüğü bir sonraki fiyat değeri (one-step-ahead) alınır.
• Önemli nokta: X_test burada gerçek gözlemlerden oluşturulan lag değerlerini içerir (yani modeli bir adım ileri tahmin için, gerçek geçmiş verileriyle test ediyoruz). Bu, one-step-ahead doğruluğunu ölçer; iteratif (modelin kendi tahminlerini girdiye eklediği) uzun dönem tahmininin davranışı farklı olabilir.

6) Performans metrikleri hesaplama

# ———- 6) Performans metrikleri ———-
from sklearn.metrics import mean_squared_error, mean_absolute_error
import math
import numpy as np

def mape(y_true, y_pred):
return np.mean(np.abs((y_true – y_pred) / y_true)) * 100

rmse_test = math.sqrt(mean_squared_error(y_test, y_pred_test))
mae_test = mean_absolute_error(y_test, y_pred_test)
mape_test = mape(y_test, y_pred_test)

print("Test performansı:")
print(f" RMSE: {rmse_test:.4f}")
print(f" MAE : {mae_test:.4f}")
print(f" MAPE (%): {mape_test:.2f}")

• Amaç: Tahminlerin doğruluğunu farklı metrikler ile nicel olarak ölçmek.
• mean_squared_error (MSE) ve mean_absolute_error (MAE) scikit-learn fonksiyonlarıdır; rmse için MSE karekökü alıyoruz.
• RMSE (Root Mean Squared Error): hataların karelerinin ortalamasının karekökü; büyük hatalara daha ağır ceza verir.
• MAE (Mean Absolute Error): hataların mutlak değerlerinin ortalaması; daha direkt ve uç değerlere daha az duyarlıdır.
• MAPE (Mean Absolute Percentage Error): hatanın yüzde olarak ortalamasını verir; hedef değerlerin sıfıra yakın olmadığı durumlarda anlamlıdır.
• math.sqrt(…) — karekök alır.
• np.abs(…) — mutlak değer alır.
• Bu metrikler modelin one-step-ahead doğruluğunu gösterir. İteratif tahminlerin kalitesini değerlendirirken referans olur.

7) İteratif 24 aylık forecast (tahminleri geri besleyerek çok adımlı tahmin)

# ———- 7) İteratif 24 aylık forecast ———-
forecast_horizon = 24 # kaç ay ileri tahmin edilecek
last_observed = df["price"].iloc[-max_lag:].values.tolist() # son max_lag gözlemini seed olarak al
iter_preds = []
iter_dates = pd.date_range(start=df.index[-1] + pd.offsets.MonthBegin(1), periods=forecast_horizon, freq="MS")

seed = last_observed.copy()
for i in range(forecast_horizon):
# modelin beklediği sıra: [t-1, t-2, …, t-12]
x = np.array([seed[-1 – k] for k in range(max_lag)])
x = x.reshape(1, -1)
pred = model.predict(x)[0]
iter_preds.append(pred)
seed.append(pred) # tahmini seed'e ekle -> bir sonraki adımda kullanılır

forecast_series = pd.Series(iter_preds, index=iter_dates, name="forecast")

• Amaç: Tek adımlık (one-step) modeli kullanarak ardışık 24 aylık tahmin üretmek. Her adımda modelin tahmini geri beslenir ve bir sonraki adım için girdi olarak kullanılır — buna iteratif (veya recursive) multi-step forecasting denir.
• last_observed = df["price"].iloc[-max_lag:].values.tolist() — son gözlemleri alıp başlangıç seed’i oluşturuyoruz; seed başlangıçta gerçek gözlemler içerir.
• iter_dates — tahminlerin hangi tarihlere karşılık geldiğini oluşturur (son gözlem tarihinden sonraki aylar).
• Döngü mantığı:
• x = np.array([seed[-1 – k] for k in range(max_lag)]) — modelin beklediği sırada (t-1, t-2, …) bir girdi vektörü oluşturur. k değeri 1'den 12'ye (yani max_lag’e) kadar. Her seferinde son 12 değer alınıyor.
• x.reshape(1, -1) — ile 1 satır ve 12 (max_lag) sütundan oluşan 2 boyutlu bir Numpy dizisi oluşturuyoruz. Böylece her bir satırdaki x kolonlarına karşılık gelen bir y değeri oluşturup, her bir tarih için alına y değerini öğrenecek şekilde eğitip, tahmin yaparken tek bir adımla periyottaki ilk tarihe karşılık gelen değeri tahmin ettirebileceğiz.
• model.predict(x) ile tek adımlık tahmini alırız.
• Tahmini seed.append(pred) ile seed’e ekleriz; dolayısıyla sonraki adım modelin bir önceki tahminini, geçmiş değer olarak kullanır.
• Dezavantaj : iteratif stratejide tahmin hataları zamanla birikebilir (öngörü hatası sonraki adımların girdisi olduğundan). Bu yüzden uzun vadede hata artışı beklenebilir.

8) Sonuçları tablo ve grafik olarak kaydetme

# ———- 8) Sonuçları tablo ve grafik olarak kaydetme ———-
import matplotlib.pyplot as plt
import os

# Tablo formatları
observed_df = pd.DataFrame({"price": series})
test_results = pd.DataFrame({"actual": y_test, "predicted_one_step": y_pred_test}, index=test_index)
forecast_df = pd.DataFrame({"forecast": iter_preds}, index=iter_dates)

# Colab-uyumlu çıktı klasörü
output_dir = "./outputs"
os.makedirs(output_dir, exist_ok=True)

# CSV olarak kaydet (isteğe bağlı)
test_results.to_csv(os.path.join(output_dir, "test_results.csv"), index=True)
forecast_df.to_csv(os.path.join(output_dir, "24mo_forecast.csv"), index=True)

# Grafik: orijinal seri, test tahminleri (one-step) ve iteratif forecast
plt.figure(figsize=(12,5))
plt.plot(observed_df.index, observed_df["price"], label="Gerçek")
plt.plot(test_results.index, test_results["predicted_one_step"], linestyle='–', label="Test one-step tahmin")
plt.plot(forecast_df.index, forecast_df["forecast"], linestyle=':', label=f"{len(iter_preds)}-ay iteratif tahmin")
plt.title("Fiyat Zaman Serisi — Gerçek, Test Tahmini (one-step) ve İteratif Tahmin")
plt.xlabel("Tarih")
plt.ylabel("Fiyat")
plt.legend()
plt.tight_layout()

plot_path = os.path.join(output_dir, "price_forecast_plot.png")
plt.savefig(plot_path)
plt.show()
plt.close()Tüm Sonuçlar

• Amaç: sonuçları hem tablo (CSV) hem de grafik olarak saklamak ve görselleştirmek.
• observed_df — tüm orijinal zaman serisini tutar; grafik çiziminde referans.
• test_results — test dönemi için gerçek değerleri ve modelin one-step tahminlerini saklar; CSV olarak kaydedilip detaylı analize açılabilir.
• forecast_df — iteratif olarak üretilen 24 aylık tahminleri tarihleriyle beraber tutar.
• os.makedirs(output_dir, exist_ok=True) — Colab ortamında ./outputs klasörünü oluşturur (varsa hata vermez). /mnt/data uyumsuzluğu nedeni ile Colab’ta bu yol daha güvenlidir.
• to_csv(…) — tabloları CSV dosyası olarak kaydeder; sonrasında indirip Excel veya başka araçlarda analiz edilebilir.
• Grafik çizimi:
• plt.plot ile gerçek seri, test dönemi tahminleri ve iteratif tahminleri aynı grafikte gösteriyoruz; görsel kıyaslama kolay olur.
• plt.savefig(plot_path) — plot ile çizilen grafiği (görseli) dosyaya yazdırır.
• plt.show() — Colab hücresinde görseli anında gösterir.
• Bu bölüm, modelin davranışını hem sayısal (CSV) hem de görsel (PNG) olarak kalıcı hale getirir; böylece sonuçları paylaşmak, raporlamak ya da daha ileri analiz yapmak kolaylaşır.

Küçük Sözlük: sık kullanılan objeler / fonksiyonlar ve kısa açıklamalar

• np.random.seed(seed) — rastgele sayı üretecini başlatır; aynı seed = tekrar üretilebilir sonuçlar.
• pd.date_range(start, periods, freq) — zaman indeksleri oluşturur; freq="MS" = Month Start.
• np.arange(n) — 0..n-1 şeklinde ardışık tamsayı dizisi.
• np.sin, np.pi — trigonometrik fonksiyonlar; mevsimsel paterni oluşturmak için kullanılır.
• pd.Series(data, index, name) — tek sütunlu zaman serisi veri yapısı; index genelde datetime olursa zaman serisi işlemleri kolay olur.
• df['col'].shift(k) — sütunu k kaydırır; geçmiş değerleri lag olarak üretmek için kullanılır.
• df.dropna() — NaN içeren satırları kaldırır.
• DataFrame.iloc — satır/kolonları konumsal olarak seçer (zaman serisi için sıralı seçme yapılır).
• sklearn.linear_model.LinearRegression — doğrusal regresyon modeli.
• model.fit(X, y) — modeli eğitir; model.predict(X) — tahmin yapar.
• mean_squared_error, mean_absolute_error — hataları ölçen fonksiyonlar.
• plt.figure, plt.plot, plt.savefig, plt.show — matplotlib ile görselleştirme ve dosyaya kaydetme.

I have no idea what you’re saying. But count me in!

Zaman Serilerinde İteratif (Yinelemeli), Çok Adımlı Tahmin Yöntemi was originally published in Türkçe Yayın on Medium, where people are continuing the conversation by highlighting and responding to this story.