15 KiB

Raw Permalink Blame History

Ramalan Siri Masa dengan Support Vector Regressor

Dalam pelajaran sebelumnya, anda telah belajar cara menggunakan model ARIMA untuk membuat ramalan siri masa. Kini anda akan melihat model Support Vector Regressor, iaitu model regresi yang digunakan untuk meramalkan data berterusan.

Kuiz pra-pelajaran

Pengenalan

Dalam pelajaran ini, anda akan meneroka cara khusus untuk membina model dengan SVM: Support Vector Machine untuk regresi, atau SVR: Support Vector Regressor.

SVR dalam konteks siri masa ¹

Sebelum memahami kepentingan SVR dalam ramalan siri masa, berikut adalah beberapa konsep penting yang perlu anda ketahui:

Regresi: Teknik pembelajaran terarah untuk meramalkan nilai berterusan daripada set input yang diberikan. Idea utamanya adalah untuk memadankan lengkung (atau garis) dalam ruang ciri yang mempunyai bilangan titik data maksimum. Klik di sini untuk maklumat lanjut.
Support Vector Machine (SVM): Jenis model pembelajaran mesin terarah yang digunakan untuk klasifikasi, regresi dan pengesanan pencilan. Model ini adalah hyperplane dalam ruang ciri, yang dalam kes klasifikasi bertindak sebagai sempadan, dan dalam kes regresi bertindak sebagai garis terbaik. Dalam SVM, fungsi Kernel biasanya digunakan untuk mengubah dataset ke ruang dengan bilangan dimensi yang lebih tinggi supaya ia mudah dipisahkan. Klik di sini untuk maklumat lanjut tentang SVM.
Support Vector Regressor (SVR): Jenis SVM, untuk mencari garis terbaik (yang dalam kes SVM adalah hyperplane) yang mempunyai bilangan titik data maksimum.

Mengapa SVR? ¹

Dalam pelajaran sebelumnya, anda telah belajar tentang ARIMA, yang merupakan kaedah linear statistik yang sangat berjaya untuk meramalkan data siri masa. Walau bagaimanapun, dalam banyak kes, data siri masa mempunyai ketidaklinearan, yang tidak dapat dipetakan oleh model linear. Dalam kes sebegini, keupayaan SVM untuk mempertimbangkan ketidaklinearan dalam data untuk tugas regresi menjadikan SVR berjaya dalam ramalan siri masa.

Latihan - bina model SVR

Langkah-langkah awal untuk penyediaan data adalah sama seperti pelajaran sebelumnya tentang ARIMA.

Buka folder /working dalam pelajaran ini dan cari fail notebook.ipynb.²

Jalankan notebook dan import pustaka yang diperlukan: ²

import sys
sys.path.append('../../')

import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt
import math

from sklearn.svm import SVR
from sklearn.preprocessing import MinMaxScaler
from common.utils import load_data, mape

Muatkan data dari fail /data/energy.csv ke dalam dataframe Pandas dan lihat: ²
```
energy = load_data('../../data')[['load']]
```

Plot semua data tenaga yang tersedia dari Januari 2012 hingga Disember 2014: ²

energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()

Sekarang, mari kita bina model SVR kita.

Cipta dataset latihan dan ujian

Sekarang data anda telah dimuatkan, anda boleh memisahkannya kepada set latihan dan ujian. Kemudian anda akan mengubah bentuk data untuk mencipta dataset berdasarkan langkah masa yang diperlukan untuk SVR. Anda akan melatih model anda pada set latihan. Selepas model selesai dilatih, anda akan menilai ketepatannya pada set latihan, set ujian dan kemudian dataset penuh untuk melihat prestasi keseluruhan. Anda perlu memastikan bahawa set ujian merangkumi tempoh masa yang lebih lewat daripada set latihan untuk memastikan model tidak mendapat maklumat daripada tempoh masa akan datang ² (situasi yang dikenali sebagai Overfitting).

Peruntukkan tempoh dua bulan dari 1 September hingga 31 Oktober 2014 kepada set latihan. Set ujian akan merangkumi tempoh dua bulan dari 1 November hingga 31 Disember 2014: ²
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```

Visualisasikan perbezaan: ²

energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
    .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
    .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()

Sediakan data untuk latihan

Sekarang, anda perlu menyediakan data untuk latihan dengan melakukan penapisan dan penskalaan data anda. Tapis dataset anda untuk hanya memasukkan tempoh masa dan lajur yang diperlukan, serta penskalaan untuk memastikan data diproyeksikan dalam julat 0,1.

Tapis dataset asal untuk hanya memasukkan tempoh masa yang disebutkan bagi setiap set dan hanya memasukkan lajur 'load' yang diperlukan serta tarikh: ²

train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
test = energy.copy()[energy.index >= test_start_dt][['load']]

print('Training data shape: ', train.shape)
print('Test data shape: ', test.shape)

Training data shape:  (1416, 1)
Test data shape:  (48, 1)

Skala data latihan untuk berada dalam julat (0, 1): ²

scaler = MinMaxScaler()
train['load'] = scaler.fit_transform(train)

Sekarang, skala data ujian: ²
```
test['load'] = scaler.transform(test)
```

Cipta data dengan langkah masa ¹

Untuk SVR, anda mengubah data input supaya berbentuk [batch, timesteps]. Jadi, anda mengubah bentuk train_data dan test_data yang sedia ada supaya terdapat dimensi baharu yang merujuk kepada langkah masa.

# Converting to numpy arrays
train_data = train.values
test_data = test.values

Untuk contoh ini, kita ambil timesteps = 5. Jadi, input kepada model adalah data untuk 4 langkah masa pertama, dan output akan menjadi data untuk langkah masa ke-5.

timesteps=5

Menukar data latihan kepada tensor 2D menggunakan list comprehension bersarang:

train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
train_data_timesteps.shape

(1412, 5)

Menukar data ujian kepada tensor 2D:

test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
test_data_timesteps.shape

(44, 5)

Memilih input dan output daripada data latihan dan ujian:

x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]

print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)

(1412, 4) (1412, 1)
(44, 4) (44, 1)

Laksanakan SVR ¹

Sekarang, tiba masanya untuk melaksanakan SVR. Untuk membaca lebih lanjut tentang pelaksanaan ini, anda boleh merujuk kepada dokumentasi ini. Untuk pelaksanaan kita, kita ikuti langkah-langkah ini:

Tentukan model dengan memanggil SVR() dan memasukkan hyperparameter model: kernel, gamma, c dan epsilon
Sediakan model untuk data latihan dengan memanggil fungsi fit()
Buat ramalan dengan memanggil fungsi predict()

Sekarang kita cipta model SVR. Di sini kita gunakan RBF kernel, dan tetapkan hyperparameter gamma, C dan epsilon sebagai 0.5, 10 dan 0.05 masing-masing.

model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)

Fit model pada data latihan ¹

model.fit(x_train, y_train[:,0])

SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
    kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)

Buat ramalan model ¹

y_train_pred = model.predict(x_train).reshape(-1,1)
y_test_pred = model.predict(x_test).reshape(-1,1)

print(y_train_pred.shape, y_test_pred.shape)

(1412, 1) (44, 1)

Anda telah membina SVR anda! Sekarang kita perlu menilainya.

Nilai model anda ¹

Untuk penilaian, pertama kita akan skala semula data kepada skala asal kita. Kemudian, untuk memeriksa prestasi, kita akan plot siri masa asal dan yang diramalkan, serta mencetak hasil MAPE.

Skala semula output yang diramalkan dan asal:

# Scaling the predictions
y_train_pred = scaler.inverse_transform(y_train_pred)
y_test_pred = scaler.inverse_transform(y_test_pred)

print(len(y_train_pred), len(y_test_pred))

# Scaling the original values
y_train = scaler.inverse_transform(y_train)
y_test = scaler.inverse_transform(y_test)

print(len(y_train), len(y_test))

Periksa prestasi model pada data latihan dan ujian ¹

Kita ekstrak cap masa daripada dataset untuk ditunjukkan pada paksi-x plot kita. Perhatikan bahawa kita menggunakan timesteps-1 nilai pertama sebagai input untuk output pertama, jadi cap masa untuk output akan bermula selepas itu.

train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
test_timestamps = energy[test_start_dt:].index[timesteps-1:]

print(len(train_timestamps), len(test_timestamps))

1412 44

Plot ramalan untuk data latihan:

plt.figure(figsize=(25,6))
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.title("Training data prediction")
plt.show()

Cetak MAPE untuk data latihan

print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')

MAPE for training data: 1.7195710200875551 %

Plot ramalan untuk data ujian

plt.figure(figsize=(10,3))
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()

Cetak MAPE untuk data ujian

print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')

MAPE for testing data:  1.2623790187854018 %

🏆 Anda mendapat keputusan yang sangat baik pada dataset ujian!

Periksa prestasi model pada dataset penuh ¹

# Extracting load values as numpy array
data = energy.copy().values

# Scaling
data = scaler.transform(data)

# Transforming to 2D tensor as per model input requirement
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
print("Tensor shape: ", data_timesteps.shape)

# Selecting inputs and outputs from data
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
print("X shape: ", X.shape,"\nY shape: ", Y.shape)

Tensor shape:  (26300, 5)
X shape:  (26300, 4) 
Y shape:  (26300, 1)

# Make model predictions
Y_pred = model.predict(X).reshape(-1,1)

# Inverse scale and reshape
Y_pred = scaler.inverse_transform(Y_pred)
Y = scaler.inverse_transform(Y)

plt.figure(figsize=(30,8))
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()

print('MAPE: ', mape(Y_pred, Y)*100, '%')

MAPE:  2.0572089029888656 %

🏆 Plot yang sangat bagus, menunjukkan model dengan ketepatan yang baik. Syabas!

🚀Cabaran

Cuba ubah hyperparameter (gamma, C, epsilon) semasa mencipta model dan nilai pada data untuk melihat set hyperparameter mana yang memberikan keputusan terbaik pada data ujian. Untuk mengetahui lebih lanjut tentang hyperparameter ini, anda boleh merujuk kepada dokumen di sini.
Cuba gunakan fungsi kernel yang berbeza untuk model dan analisis prestasi mereka pada dataset. Dokumen yang berguna boleh didapati di sini.
Cuba gunakan nilai yang berbeza untuk timesteps untuk model melihat ke belakang untuk membuat ramalan.

Kuiz pasca-pelajaran

Ulasan & Kajian Kendiri

Pelajaran ini bertujuan untuk memperkenalkan aplikasi SVR untuk Ramalan Siri Masa. Untuk membaca lebih lanjut tentang SVR, anda boleh merujuk kepada blog ini. Dokumentasi ini pada scikit-learn menyediakan penjelasan yang lebih komprehensif tentang SVM secara umum, SVRs dan juga butiran pelaksanaan lain seperti fungsi kernel yang berbeza yang boleh digunakan, dan parameternya.

Tugasan

Model SVR baharu

Kredit

Penafian:
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI Co-op Translator. Walaupun kami berusaha untuk memastikan ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat yang kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.

Teks, kod dan output dalam bahagian ini disumbangkan oleh @AnirbanMukherjeeXD ↩︎
Teks, kod dan output dalam bahagian ini diambil daripada ARIMA ↩︎

15 KiB Raw Permalink Blame History