Chronos-T5-Small: Zaman Serisi Tahmini için Özel Dil Modeli

---

Chronos-T5-Small Model Detayları

Model Hakkında

Chronos-T5-Small, Amazon tarafından geliştirilmiş, zaman serisi tahmini için özelleştirilmiş bir dil modelidir. Geleneksel zaman serisi yöntemlerinden farklı olarak, zaman serisi verilerini token’lar halinde ele alarak dil modelleme tekniklerini zaman serisi tahminine uyarlar.

Teknik Özellikler:

• Mimari: T5 (Text-to-Text Transfer Transformer) tabanlı
• Model Boyutu: Küçük (small) versiyon
• Parametre Sayısı: ~20M
• Giriş Formatı: Zaman serisi token’ları
• Çıkış Formatı: Gelecek zaman periyotları tahmini
• Eğitim Verisi: Çeşitli zaman serisi veri kümeleri

Temel Çalışma Prensibi:

Zaman serisi verilerini bir dil gibi ele alır:

• Zaman serisi değerleri → Token’lar
• Zaman serisi pattern’leri → Dil yapıları
• Tahmin → Metin üretimi benzeri çıktı

Kullanım Alanları:

• Finansal tahmin (hisse senedi, döviz kuru)
• Talep tahmini (perakende, üretim)
• Enerji tüketimi tahmini
• Hava durumu ve iklim verisi analizi
• IoT sensör verisi tahmini

---

İndirme ve Erişim

Resmi Model Sayfası:
https://huggingface.co/amazon/chronos-t5-small

Model Ailesi:

• chronos-t5-small (~20M parametre)
• chronos-t5-base (~80M parametre)
• chronos-t5-large (~200M parametre)

İndirme Seçenekleri:

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

model_name = "amazon/chronos-t5-small"
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

---

Kurulum ve Temel Kullanım

Gereksinimler:

pip install transformers torch
pip install pandas numpy matplotlib
pip install datasets

Temel Zaman Serisi Tahmini:

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
import numpy as np

# Model ve tokenizer yükleme
model_name = "amazon/chronos-t5-small"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

# Zaman serisi verisi (örnek)
time_series = [10.2, 11.5, 12.8, 14.1, 15.4, 16.7, 18.0]

# Tokenization ve tahmin
inputs = tokenizer(time_series, return_tensors="pt", padding=True)

with torch.no_grad():
    outputs = model.generate(
        inputs.input_ids,
        max_length=20,
        num_beams=5,
        early_stopping=True
    )

# Tahminleri decode etme
predictions = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Tahminler:", predictions)

Detaylı Kullanım Örneği:

import pandas as pd
from chronos import ChronosPipeline

# Chronos pipeline ile tahmin
pipeline = ChronosPipeline.from_pretrained("amazon/chronos-t5-small")

# Zaman serisi verisi
series = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])

# Tahmin yapma
forecast = pipeline.predict(series, prediction_length=5)
print("5 periyotluk tahmin:", forecast)

---

Veri Hazırlama ve Ön İşleme

Zaman Serisi Formatı:

# Pandas Series formatı
import pandas as pd
time_series = pd.Series(
    data=[100, 110, 120, 130, 140, 150],
    index=pd.date_range('2024-01-01', periods=6, freq='D')
)

# NumPy array formatı
import numpy as np
time_series_array = np.array([100, 110, 120, 130, 140, 150])

Özellik Mühendisliği:

def prepare_timeseries_data(data, context_length=10):
    """
    Zaman serisi verisini model için hazırlama
    """
    # Normalizasyon
    mean = data.mean()
    std = data.std()
    normalized_data = (data - mean) / std

    # Context window oluşturma
    windows = []
    for i in range(len(normalized_data) - context_length):
        window = normalized_data[i:i+context_length]
        windows.append(window)

    return windows, mean, std

---

Eğitim ve Fine-Tuning

Transfer Learning için:

from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer

# Fine-tuning configuration
training_args = Seq2SeqTrainingArguments(
    output_dir="./chronos-finetuned",
    per_device_train_batch_size=4,
    prediction_loss_only=True,
    learning_rate=5e-5,
    num_train_epochs=10,
)

# Trainer oluşturma
trainer = Seq2SeqTrainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
)

Özel Veri Kümesi ile Eğitim:

from datasets import Dataset
import pandas as pd

# Özel zaman serisi veri kümesi oluşturma
def create_dataset(time_series_list, context_length=20, prediction_length=5):
    examples = []
    for series in time_series_list:
        for i in range(len(series) - context_length - prediction_length):
            input_seq = series[i:i+context_length]
            target_seq = series[i+context_length:i+context_length+prediction_length]
            examples.append({
                'input_ids': input_seq,
                'labels': target_seq
            })
    return Dataset.from_list(examples)

---

Değerlendirme ve Metrikler

Tahmin Kalitesi Metrikleri:

from sklearn.metrics import mean_absolute_error, mean_squared_error

def evaluate_predictions(actual, predicted):
    """
    Tahmin performansını değerlendirme
    """
    mae = mean_absolute_error(actual, predicted)
    mse = mean_squared_error(actual, predicted)
    rmse = np.sqrt(mse)

    return {
        'MAE': mae,
        'MSE': mse, 
        'RMSE': rmse,
        'MAPE': np.mean(np.abs((actual - predicted) / actual)) * 100
    }

---

Production Kullanımı

API Entegrasyonu:

from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.post("/predict")
async def predict_timeseries(data: dict):
    time_series = data["series"]
    predictions = pipeline.predict(time_series, prediction_length=data.get("horizon", 5))
    return {"predictions": predictions.tolist()}

# Çalıştırma: uvicorn main:app --reload

Batch Tahminleme:

def batch_predict(time_series_list, prediction_length=5):
    """
    Toplu zaman serisi tahmini
    """
    all_predictions = []
    for series in time_series_list:
        prediction = pipeline.predict(series, prediction_length=prediction_length)
        all_predictions.append(prediction)
    return all_predictions

---

Performans Optimizasyonu

GPU Kullanımı:

# GPU desteği
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Mixed precision training
from torch.cuda.amp import autocast
with autocast():
    outputs = model(**inputs)

Bellek Optimizasyonu:

# Gradient checkpointing
model.gradient_checkpointing_enable()

# Dynamic padding
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, padding=True)

---

Sınırlamalar ve Çözümler

Sınırlamalar:

• ⚠️ Uzun zaman serilerinde performans düşüşü
• ⚠️ Mevsimsel pattern’lerde zorluk
• ⚠️ Anomali içeren verilerde yanılgı

Çözüm Önerileri:

• ✅ Veri ön işleme ve temizleme
• ✅ Model fine-tuning
• ✅ Ensemble yöntemleri
• ✅ Hybrid modeller (geleneksel + ML)

---

Not: Chronos-T5 modelleri, zaman serisi tahmininde dil modelleme yaklaşımının öncülerindendir. Hem akademik hem de endüstriyel uygulamalar için uygundur.