TimeGPT ile Zaman Serisi Tahmini

TimeGPT’ye Başlarken

TimeGPT modeli açık kaynak değildir ve yalnızca Nixtla API’si üzerinden erişilebilir. Bu bölümde, TimeGPT modeline erişmek ve Amazon hisse senedi verileri üzerinde tahmin yapmak için Nixtla API kurulumunu adım adım göreceksiniz.

1. dashboard.nixtla.io adresini ziyaret ederek bir API anahtarı üretmemiz gerekecek. API anahtarı oluşturmak için bir hesap oluşturmamız istenecek. Şu anda TimeGPT’ye ücretsiz erişim mümkün, ancak API çağrılarında bazı sınırlamalar var.

2. Kodlama ortamı olarak DataCamp’in DataLab’ini kullanıyoruz. DataLab, herkesin birkaç saniye içinde kodlamaya başlamasını kolaylaştıran, bulut tabanlı ve ücretsiz bir Jupyter Notebook’tur. DataLab’de ortam değişkenlerini ayarlamak için "Environment" sekmesine, ardından "Environment variables..." düğmesine tıklayın, "+ Add" düğmesine basın ve değişken adını ve API anahtarını ekleyin.

3. Model için Nixtla Python istemcisini ve borsa veri kümesi için Yahoo Finance kütüphanesini kurun. 

%%capture
%pip install nixtla>=0.5.1
%pip install yfinance

4. TimeGPT API anahtarıyla Nixtla istemcisini oluşturun.
5. Amazon hisse fiyatı verilerini indirin, indeksini sıfırlayın ve ilk beş satırı gösterin.

import pandas as pd
import yfinance as yf
from nixtla import NixtlaClient
import os

timegpt_api_key = os.environ["TIMEGPT_API_KEY"]

# Setup NixtlaClient
nixtla_client = NixtlaClient(api_key = timegpt_api_key)


# Downloading Amazon stock price data
ticker = 'AMZN'
amazon_stock_data = yf.download(ticker)
amazon_stock_data = amazon_stock_data.reset_index()

# Displaying the dataset
amazon_stock_data.head()

1997’den günümüze Amazon hisse fiyatı verilerine sahibiz.

6. Nixtla istemcisini kullanarak hisse fiyatı verilerini kolayca çizebiliriz. 

nixtla_client.plot(amazon_stock_data, time_col='Date', target_col='Close')

Matplotlib kullanarak zaman serisi çizgi grafiklerini nasıl oluşturacağınızı bu Matplotlib Zaman Serisi Çizgi Grafiği öğreticisini izleyerek keşfedin.

7. Tahmin yapmak için .forecast fonksiyonuna hisse verisini, model adını, öngörü ufkunu (24 güne eşdeğer), frekansı, zaman sütunlarını ve hedef sütunları sağlamamız gerekir. Borsa hafta sonları kapalı olduğundan frekansı "iş günü (B)" olarak seçiyoruz.

model = nixtla_client.forecast(
    df=amazon_stock_data,
    model="timegpt-1",
    h=24,
    freq="B",
    time_col="Date",
    target_col="Close",
)
model.tail()

8. Gerçek ve tahmin veri kümelerini, maksimum örnek uzunluğu 60 olacak şekilde çizin. Bu, modelin tahmininin daha yakından görünmesi için yalnızca son 60 değerin çizileceği anlamına gelir.

nixtla_client.plot(
    amazon_stock_data,
    model,
    time_col="Date",
    target_col="Close",
    max_insample_length=60,
)

Gördüğünüz gibi, TimeGPT modeli birkaç saniye içinde Amazon’un kapanış fiyatlarını geleceğe yönelik olarak isabetli biçimde tahmin etti. 

Bu bir başlangıç örneğiydi. Bir sonraki bölümde daha karmaşık veri kümeleriyle çalışacak ve Nixtla API’nin çeşitli özelliklerini keşfedeceğiz.

TimeGPT ile Avustralya Elektrik Talebinin Tahmini

Bu bölümde daha karmaşık bir Avustralya Elektrik Talebi veri kümesi kullanacak ve TimeGPT modeliyle aynı anda birden fazla değeri tahmin edeceğiz. 

Veri kümesi, Avustralya’daki 5 eyaletin (Victoria, New South Wales, Queensland, Tazmanya ve Güney Avustralya) yarım saatte bir elektrik talebini temsil eden 5 zaman serisinden oluşur.

Ayrıca modeli nasıl ince ayar yapacağımızı ve performansı artırmak için çeşitli model hiperparametrelerini nasıl kullanacağımızı öğreneceğiz. Son olarak çapraz doğrulama yapacak ve kapsamlı bir değerlendirme için modelin performansını geleneksel modellerle karşılaştıracağız.

Veri kümesini yükleme

pandas kütüphanesinde .tsf dosyasını yüklemenin basit bir yolu yok. Verileri yüklemek ve işlemek için kendi özel fonksiyonumuzu oluşturup ardından bir Pandas veri çerçevesine dönüştürmemiz gerekiyor.

import pandas as pd


def read_tsf_from_file(file_path):
    data = []
    start_date = pd.to_datetime("2002-01-01 00:00:00")

    # Open and read the file from the directory

    with open(file_path, "r") as file:
        for line in file:
            if line.startswith("T"):
                parts = line.strip().split(":")
                unique_id = parts[0] + "-" + parts[1]
                values = list(map(float, parts[3].split(",")[:-1]))

                # Generate datetime index at half-hour intervals

                periods = len(values)
                date_range = pd.date_range(
                    start=start_date, periods=periods, freq="30min"
                )

                # Append to data list

                for dt, value in zip(date_range, values):
                    data.append([unique_id, dt, value])
    # Convert the list of data into a DataFrame

    return pd.DataFrame(data, columns=["unique_id", "ds", "y"])


# Example usage

file_path = "australian_electricity_demand_dataset.tsf"
demand_df = read_tsf_from_file(file_path)

# Display the dataframe

demand_df.head()

Veri kümemizde üç sütun bulunuyor: 

1. unique_id: Avustralya’daki 5 eyaleti temsil eder.
2. ds: tarih ve saat.
3. y: elektrik talebi.

plot fonksiyonu harika; unique_id sütununu otomatik olarak algılar ve beş farklı zaman serisi görselleştirmesi oluşturur.

nixtla_client.plot(
    demand_df, 
    max_insample_length=365, 
)

Aşağıdaki görselleştirme 5 eyaletin güç tüketimini gösteriyor ve her birinin farklı örüntüleri var.

Zaman serisi analizini öğrenmek için DataCamp’teki canlı birlikte kodlama oturumuna katılın; burada Python ile finansal zaman serisi veri kümelerine dalacaksınız. 

Bu oturumda çeşitli hisseleri keşfedecek, performanslarını görselleştirecek ve farklı modellerle tahminler yapacağız.

Anomali tespiti

Tahmin yapmadan önce, problemi daha iyi anlamak için veri kümesindeki çeşitli anomalileri belirleyeceğiz. 

.detect_anomalies fonksiyonu veri kümesini, zaman ve hedef sütunlarını ve frekansı alır. 

# Detect anomalies
anomalies_df = nixtla_client.detect_anomalies(
    demand_df, 
    time_col='ds', 
    target_col='y', 
    freq='H', 
)
anomalies_df[anomalies_df["anomaly"]==1].head()

Anomali tespit edilen tüm örnekleri görüntüledik. 

Tüm 5 zaman serisi veri kümesindeki toplam anomali sayısı 17.316, bu da oldukça fazla.

anomalies_df.anomaly.value_counts()

Şimdi, anomalilerin nerede ve ne sıklıkla meydana geldiğini görmek için bunları gerçek veri kümesi üzerinde çizeceğiz. Görselleştirmeyi sadeleştirmek için yalnızca New South Wales’ten 5.000 örnek göstereceğiz.

# Plot anomalies
nixtla_client.plot(
    demand_df[demand_df["unique_id"]=="T1-NSW"][0:5000], 
    anomalies_df[anomalies_df["unique_id"]=="T1-NSW"][0:5000],
    time_col='ds', 
    target_col='y',
    
)

Günlük bazda anomaliler yaygın değil, ancak tek bir günde birden fazla anomali görülen günler olmuş.

TimeGPT ile tek seri tahmini

Şimdi New South Wales elektrik talebini tahmin edeceğiz. Bunun için yalnızca "T1-NSW" değerlerini filtreleyeceğiz.

T1_df = demand_df[demand_df["unique_id"]=="T1-NSW"]
T1_df.head()

Elektrik tüketim örüntüsünü anlamak için son 365 değeri çizin. 

nixtla_client.plot(
    T1_df, 
    max_insample_length=365, 
)

Şimdi modelimizin performansını değerlendireceğiz. Bunun için veri kümemizi eğitim ve test setlerine ayırmamız gerekiyor. 

Eğitim seti 3 güne karşılık gelen 144 değerden, test seti ise 25 güne karşılık gelen 1200 değerden oluşuyor.

test_df = T1_df.tail(144) # 3 days = (144 * 0.5h *  1 day/24h) 
train_df = T1_df.iloc[-1344:-144] # 25 days = (1200 *0.5h * 1 day/24h)

Tahmin için daha iyi bir model seçip çeşitli argümanları ayarlayarak model performansını artıracağız; özellikle:

1. Sonraki 144 değeri (3 gün) tahmin edin.
2. %90 güven aralığı üretin. 
3. Modeli 60 adımda ince ayar yapın; bu çoktur ama daha iyi sonuç verecektir. 
4. Kayıp fonksiyonunu MAE olarak ayarlayın. 
5. Basit model yerine TimeGPT-1-long-horizon modelini kullanın. 
6. Zaman ve hedef sütunlarını ayarlayın. 

predict_df = nixtla_client.forecast(
    df=train_df,
    h=144,
    level=[90],  # Generate a 90% confidence interval
    finetune_steps=60,  # Specify the number of steps for fine-tuning
    finetune_loss="mae",  # Use the MAE as the loss function for fine-tuning
    model="timegpt-1-long-horizon",  # Use the model for long-horizon forecasting
    time_col="ds",
    target_col="y",
)

Modelin performansını değerlendirmek için gerçek, tahmin ve %90 güven aralığını çizin.

nixtla_client.plot(
    test_df, predict_df, models=["TimeGPT"], level=[90], time_col="ds", target_col="y"
)

Birkaç saniye içinde oldukça isabetli bir sonuç aldık. Bu, önceden eğitilmiş modellerin gücüdür.

Model performansını, Nixtla açık kaynak projesinin bir parçası olan UtilsForecast kütüphanesiyle değerlendireceğiz. Bunun için test ve tahmin veri kümelerini birleştirip evaluate fonksiyonuna vereceğiz. Fonksiyon, veri kümesini, metrikleri, modelleri, hedef sütununu ve benzersiz kimliği alarak model metriklerini hesaplar ve bunları bir pandas veri çerçevesi olarak gösterir.

from utilsforecast.losses import mae, rmse, smape
from utilsforecast.evaluation import evaluate

predict_df["ds"] = pd.to_datetime(predict_df["ds"])
test_df = pd.merge(test_df, predict_df, "left", ["ds", "unique_id"])
evaluation = evaluate(
    test_df,
    metrics=[mae, rmse, smape],
    models=["TimeGPT"],
    target_col="y",
    id_col="unique_id",
)

average_metrics = evaluation.groupby("metric")["TimeGPT"].mean()
average_metrics

Oldukça iyi sonuçlar elde ettik. 

TimeGPT ile çoklu seri tahmini

Nixtla API, aynı anda birden fazla seriyi de tahmin etmenize olanak tanır. Benzersiz kimliğe göre filtrelemek yerine tüm veri kümesini kullanacağız. 

Veri kümesini eğitim ve test setlerine bölmek için, her bir benzersiz kimlik için 144 değeri ayırmak üzere groupby fonksiyonunu kullanıyoruz. Aksi halde rastgele seçilmiş bir benzersiz kimlik için yalnızca 144 değerimiz olurdu.

values for some randomly chosen unique ID.
test_df = demand_df.groupby("unique_id").tail(144)  # 3 days
train_df = (
    demand_df.groupby("unique_id")
    .apply(lambda group: group.iloc[-1344:-144])
    .reset_index(drop=True)
)  # 25 days

forecast fonksiyonu önceki bölümle aynıdır; tek fark, bu kez kimlik sütunlarını da dahil ediyoruz.

predict_df = nixtla_client.forecast(
    df=train_df,
    h=144,                            
    level=[90],                        
    finetune_steps=60,                 
    finetune_loss='mae',               
    model='timegpt-1-long-horizon',    
    time_col='ds',
    target_col='y',
    id_col='unique_id'
)

Tüm 5 benzersiz kimlik için gerçek, tahmin ve %90 güven düzeyi değerlerinin zaman serisi grafiğini çizin.

nixtla_client.plot(
    test_df, predict_df, models=["TimeGPT"], level=[90], time_col="ds", target_col="y"
)

Görüldüğü gibi, TimeGPT modeli çoklu zaman serilerinde de iyi performans gösterdi; Güney Avustralya hariç. Elektrik talebindeki aşağı yönlü eğilimi tahmin edemedi.

Modeli MAE, RMSE ve SMAPE metrikleriyle değerlendirmek için test ve tahmin veri çerçevelerini birleştirmemiz gerekiyor.

predict_df['ds'] = pd.to_datetime(predict_df['ds'])
test_df = pd.merge(test_df, predict_df, 'left', ['ds','unique_id'])

evaluate fonksiyonunu kullanarak bir model performans raporunu pandas veri çerçevesi olarak üretin. Rapor, her benzersiz kimlik için model metriklerini içerecek. Modelin genel performansını hesaplamak için değerleri ortalamamız ve nihai sonucu göstermemiz gerekir. 

evaluation = evaluate(
    test_df,
    metrics=[mae, rmse, smape],
    models=["TimeGPT"],
    target_col="y",
    id_col = "unique_id"
)

average_metrics = evaluation.groupby('metric')["TimeGPT"].mean()
average_metrics

Genel model performansı, tek bir seri yerine birden fazla zaman serisi üzerinde ince ayar yapıldığında iyileşir.

Çapraz doğrulama

Nixtla istemcisi, veri kümesinin çeşitli pencerelerinde model performansını değerlendirmek için çapraz doğrulama yapmanıza da olanak tanır.

.cross_validation fonksiyonunu kullanacak ve yalnızca New South Wales değerlerini içeren filtrelenmiş veri kümesini vereceğiz. Çapraz doğrulama 7 saat uzunluğunda 5 pencereye sahip olacak.

timegpt_cv_df = nixtla_client.cross_validation(
    T1_df, 
    h=7, 
    n_windows=5, 
    time_col='ds', 
    target_col='y', 
    freq='H',
)
timegpt_cv_df.head()

Görüldüğü gibi, beş adet 7 saatlik pencereye dayalı tahmin değerleri elde ettik.

Tahmin edilen ve gerçek değerleri göstermek için 5 pencere oluşturacak bir kesim tarih ve saati kullanacağız.

cutoffs = timegpt_cv_df['cutoff'].unique()
for cutoff in cutoffs:
    fig = nixtla_client.plot(
        T1_df.tail(100), 
        timegpt_cv_df.query('cutoff == @cutoff').drop(columns=['cutoff', 'y']),
        time_col='ds', 
        target_col='y'
    )
    display(fig)

3. ve 4. bölmeler dışında model oldukça iyi performans gösterdi.

LGBM ile TimeGPT’nin karşılaştırılması

Şimdi TimeGPT ve Light Gradient-Boosting Machine (LGBM) modellerinin performansını aynı veri kümesinde hangisinin üstün olduğunu net biçimde görmek için karşılaştıralım. New South Wales veri çerçevesinde çapraz doğrulamayı zaten gerçekleştirdik; sıradaki adım evaluate fonksiyonunu kullanarak model değerlendirme raporu üretmek.

evaluation = evaluate(
    timegpt_cv_df,
    metrics=[mae, rmse, smape],
    models=["TimeGPT"],
    target_col="y",
    id_col = "cutoff"
)
evaluation

Modelin genel sonucunu elde etmek için tüm 5 pencere için MAE, RMSE ve SMAPE ortalamasını hesaplamamız gerekir.

average_metrics = evaluation.groupby('metric')["TimeGPT"].mean()
average_metrics

Sonuçlar, küçük bir değer kümesi üzerinde bile oldukça iyi. 

LGBM modelini değerlendirmek için şu adımları izlememiz gerekiyor:

1. Veriyi filtreleyin: Verinin, TimeGPT çapraz doğrulamasında kullanılan değerlere benzer olduğundan emin olun.
2. Tarih-saat dönüşümü: Tarih-saat bilgisini sayısal değerlere dönüştürün.
3. Özellik mühendisliği: Gecikme ve kaydırmalı pencere teknikleriyle ek özellikler oluşturun.
4. Eksik değerlerle başa çıkma: Gecikmeler ve kaydırmalı pencerelerden kaynaklanabilecek eksik değerleri düşürün.
5. Modelleme için veri hazırlığı: Özellik matrisi X ve hedef vektörü y’yi tanımlayın ve TimeSeriesSplit ile bölün.
6. Eğitme ve değerlendirme: Modeli eğitin, değerlendirin ve her veri bölmesi için metrikleri kaydedin.
7. Sonuçların birleştirilmesi: Her model metriğinin ortalamasını hesaplayın ve sonuçları bir pandas DataFrame’inde gösterin.

Not: Zaman serisi tahmini için istatistiksel ve makine öğrenimi modellerini kullanmak istiyorsanız temel özellik mühendisliği tekniklerini ve algoritmaları öğrenmek şarttır. Bu konulara kapsamlı bir giriş için şu öğreticiye göz atın: DataCamp’te Zaman Serisi Tahmini Öğreticisi.

import pandas as pd
import numpy as np
import lightgbm as lgb
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import mean_absolute_error, mean_squared_error

# Function to calculate SMAPE
def smape(y_true, y_pred):
    return np.mean(2 * np.abs(y_pred - y_true) / (np.abs(y_true) + np.abs(y_pred)))

# Assuming 'ds' is the date/time column and 'y' is the target variable
T1_df['ds'] = pd.to_datetime(T1_df['ds'])

# Filter the DataFrame to include only the specified datetime range
start_date = '2015-02-27T13:00:00'
end_date = '2015-02-28T23:00:00'
T1_df = T1_df[(T1_df['ds'] >= start_date) & (T1_df['ds'] <= end_date)]

# Convert 'ds' to a numerical value (e.g., timestamp)
T1_df['ds_num'] = T1_df['ds'].apply(lambda x: x.timestamp())

# Create lag and window features
for lag in range(1, 4):
    T1_df[f'lag_{lag}'] = T1_df['y'].shift(lag)

T1_df['rolling_mean'] = T1_df['y'].rolling(window=3).mean()
T1_df['rolling_std'] = T1_df['y'].rolling(window=3).std()

# Drop NaN values resulting from lag and rolling operations
T1_df.dropna(inplace=True)

# Select features for the model
X = T1_df[['ds_num', 'lag_1', 'lag_2', 'lag_3', 'rolling_mean', 'rolling_std']]
y = T1_df['y']

# Time series split
tscv = TimeSeriesSplit(n_splits=5)
mae_scores = []
rmse_scores = []
smape_scores = []

for train_index, test_index in tscv.split(X):
    X_train, X_test = X.iloc[train_index], X.iloc[test_index]
    y_train, y_test = y.iloc[train_index], y.iloc[test_index]

    # Initialize and train the LGBM model
    model = lgb.LGBMRegressor(force_row_wise=True, verbosity=-1)
    model.fit(X_train, y_train)

    # Make predictions
    y_pred = model.predict(X_test)

    # Evaluate the model
    mae = mean_absolute_error(y_test, y_pred)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    smape_value = smape(y_test, y_pred)

    mae_scores.append(mae)
    rmse_scores.append(rmse)
    smape_scores.append(smape_value)

# Convert the metrics into a DataFrame
mae_avg = np.mean(mae_scores)
rmse_avg = np.mean(rmse_scores)
smape_avg = np.mean(smape_scores)

metrics_df = pd.DataFrame({
    'metric': ['MAE', 'RMSE', 'SMAPE'],
    'LGBM': [mae_avg, rmse_avg, smape_avg]
})

# Display the DataFrame
metrics_df

TimeGPT, LGBM’den neredeyse 5 kat daha iyi. 

Yukarıdaki kodu çalıştırırken veya TimeGPT’yi kurarken sorun yaşıyorsanız, lütfen DataLab çalışma alanına göz atın: TimeGPT ile Zaman Serisi Tahmini. 

Sonuç

TimeGPT ve Nixtla ekosistemi, yeni başlayan şirketler için idealdir; modelleri eğitmek için makine öğrenimi mühendisleri ve bunları devreye almak ile sürdürmek için MLOps mühendisleri tutma gereğini ortadan kaldırır. Bir girişimseniz, yüksek performanslı modellere erişirken önemli ölçüde maliyet tasarrufu sağlayabilirsiniz. 

GPT-3’e benzer şekilde, TimeGPT zaman serileri için son teknoloji modellerin başlangıcını temsil eder ve bu modeller zamanla geliştikçe, pek çok şirketin kolay entegrasyon ve daha yüksek performans için Nixtla API’sini benimsemesi muhtemeldir.

Bu eğitimde, zaman serileri için ilk temel model olan TimeGPT’yi inceledik. Ayrıca, kestirim, zaman serisi görselleştirmesi, model değerlendirmesi, çapraz doğrulama ve anomali tespiti gibi görevlerde TimeGPT modeline erişmek için Python API’sinin nasıl kullanılacağını öğrendik.

ARIMA sınıfı modellerle geleceği nasıl tahmin edeceğinizi ve makine öğrenimi modelleriyle tahmin ve içgörü nasıl üreteceğinizi Python ile Zaman Serileri yetkinlik yoluyla öğrenin. R dilini tercih ediyorsanız, zaman serisi tahminini kapsamlıca anlamak için R ile Zaman Serileri yetkinlik yolunu değerlendirin.