History

leestott ffd4047095 🌐 Update translations via Co-op Translator		2 weeks ago
..
solution	🌐 Update translations via Co-op Translator	3 weeks ago
working	🌐 Update translations via Co-op Translator	3 weeks ago
README.md	🌐 Update translations via Co-op Translator	2 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	2 weeks ago

README.md

Predviđanje vremenskih serija pomoću Support Vector Regressor-a

U prethodnoj lekciji naučili ste kako koristiti ARIMA model za predviđanje vremenskih serija. Sada ćemo se fokusirati na model Support Vector Regressor, koji se koristi za predviđanje kontinuiranih podataka.

Pre-lecture kviz

Uvod

U ovoj lekciji otkrit ćete specifičan način izgradnje modela pomoću SVM: Support Vector Machine za regresiju, ili SVR: Support Vector Regressor.

SVR u kontekstu vremenskih serija ¹

Prije nego što razumijete važnost SVR-a u predviđanju vremenskih serija, evo nekoliko važnih pojmova koje trebate znati:

Regresija: Tehnika nadziranog učenja za predviđanje kontinuiranih vrijednosti iz skupa ulaznih podataka. Ideja je prilagoditi krivulju (ili liniju) u prostoru značajki koja ima maksimalan broj podataka. Kliknite ovdje za više informacija.
Support Vector Machine (SVM): Vrsta modela nadziranog strojnog učenja koji se koristi za klasifikaciju, regresiju i otkrivanje odstupanja. Model je hiperravnina u prostoru značajki, koja u slučaju klasifikacije djeluje kao granica, a u slučaju regresije kao linija najboljeg pristajanja. U SVM-u se obično koristi Kernel funkcija za transformaciju skupa podataka u prostor s većim brojem dimenzija, kako bi se podaci lakše razdvojili. Kliknite ovdje za više informacija o SVM-ovima.
Support Vector Regressor (SVR): Vrsta SVM-a, koja pronalazi liniju najboljeg pristajanja (koja je u slučaju SVM-a hiperravnina) s maksimalnim brojem podataka.

Zašto SVR? ¹

U prethodnoj lekciji naučili ste o ARIMA modelu, koji je vrlo uspješna statistička linearna metoda za predviđanje vremenskih serija. Međutim, u mnogim slučajevima podaci vremenskih serija imaju nelinearnost, koju linearni modeli ne mogu mapirati. U takvim slučajevima sposobnost SVM-a da uzme u obzir nelinearnost podataka za regresijske zadatke čini SVR uspješnim u predviđanju vremenskih serija.

Vježba - izgradnja SVR modela

Prvi koraci za pripremu podataka isti su kao u prethodnoj lekciji o ARIMA.

Otvorite mapu /working u ovoj lekciji i pronađite datoteku notebook.ipynb. ²

Pokrenite notebook i uvezite potrebne biblioteke: ²

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

Učitajte podatke iz datoteke /data/energy.csv u Pandas dataframe i pogledajte ih: ²
```
energy = load_data('../../data')[['load']]
```

Prikažite sve dostupne podatke o energiji od siječnja 2012. do prosinca 2014.: ²

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

Sada ćemo izgraditi naš SVR model.

Kreiranje skupa za treniranje i testiranje

Sada su vaši podaci učitani, pa ih možete podijeliti na skup za treniranje i skup za testiranje. Zatim ćete preoblikovati podatke kako biste stvorili skup podataka temeljen na vremenskim koracima, što će biti potrebno za SVR. Model ćete trenirati na skupu za treniranje. Nakon što model završi s treniranjem, procijenit ćete njegovu točnost na skupu za treniranje, skupu za testiranje i zatim na cijelom skupu podataka kako biste vidjeli ukupnu izvedbu. Morate osigurati da skup za testiranje pokriva kasniji vremenski period od skupa za treniranje kako biste osigurali da model ne dobije informacije iz budućih vremenskih perioda ² (situacija poznata kao Overfitting).

Dodijelite dvomjesečno razdoblje od 1. rujna do 31. listopada 2014. skupu za treniranje. Skup za testiranje uključivat će dvomjesečno razdoblje od 1. studenog do 31. prosinca 2014.: ²
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```

Vizualizirajte razlike: ²

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()

Priprema podataka za treniranje

Sada trebate pripremiti podatke za treniranje filtriranjem i skaliranjem podataka. Filtrirajte svoj skup podataka tako da uključuje samo potrebne vremenske periode i stupce, te skalirajte podatke kako biste osigurali da su projicirani u interval 0,1.

Filtrirajte originalni skup podataka tako da uključuje samo prethodno navedene vremenske periode po skupu i samo potrebni stupac 'load' plus datum: ²

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)

Skalirajte podatke za treniranje u raspon (0, 1): ²

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

Sada skalirajte podatke za testiranje: ²
```
test['load'] = scaler.transform(test)
```

Kreiranje podataka s vremenskim koracima ¹

Za SVR, transformirate ulazne podatke u oblik [batch, timesteps]. Dakle, preoblikujete postojeće train_data i test_data tako da postoji nova dimenzija koja se odnosi na vremenske korake.

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

Za ovaj primjer uzimamo timesteps = 5. Dakle, ulazi u model su podaci za prva 4 vremenska koraka, a izlaz će biti podaci za 5. vremenski korak.

timesteps=5

Pretvaranje podataka za treniranje u 2D tensor pomoću ugniježđenih list comprehensions:

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)

Pretvaranje podataka za testiranje u 2D tensor:

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)

Odabir ulaza i izlaza iz podataka za treniranje i testiranje:

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)

Implementacija SVR-a ¹

Sada je vrijeme za implementaciju SVR-a. Za više informacija o ovoj implementaciji, možete se referirati na ovu dokumentaciju. Za našu implementaciju slijedimo ove korake:

Definirajte model pozivanjem SVR() i prosljeđivanjem hiperparametara modela: kernel, gamma, c i epsilon
Pripremite model za podatke za treniranje pozivanjem funkcije fit()
Napravite predviđanja pozivanjem funkcije predict()

Sada kreiramo SVR model. Ovdje koristimo RBF kernel, i postavljamo hiperparametre gamma, C i epsilon na 0.5, 10 i 0.05.

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

Treniranje modela na podacima za treniranje ¹

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)

Izrada predviđanja modela ¹

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)

Izgradili ste svoj SVR! Sada ga trebamo procijeniti.

Procjena modela ¹

Za procjenu, prvo ćemo skalirati podatke natrag na našu originalnu skalu. Zatim, kako bismo provjerili izvedbu, prikazat ćemo originalni i predviđeni graf vremenskih serija, te ispisati rezultat MAPE-a.

Skaliranje predviđenih i originalnih izlaza:

# 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))

Provjera izvedbe modela na podacima za treniranje i testiranje ¹

Izvlačimo vremenske oznake iz skupa podataka kako bismo ih prikazali na x-osi našeg grafa. Napominjemo da koristimo prvih timesteps-1 vrijednosti kao ulaz za prvi izlaz, tako da vremenske oznake za izlaz počinju nakon toga.

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

Prikaz predviđanja za podatke za treniranje:

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()

Ispis MAPE-a za podatke za treniranje

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

MAPE for training data: 1.7195710200875551 %

Prikaz predviđanja za podatke za testiranje

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()

Ispis MAPE-a za podatke za testiranje

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

MAPE for testing data:  1.2623790187854018 %

🏆 Imate vrlo dobar rezultat na skupu podataka za testiranje!

Provjera izvedbe modela na cijelom skupu podataka ¹

# 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 %

🏆 Vrlo lijepi grafovi, koji pokazuju model s dobrom točnošću. Bravo!

🚀Izazov

Pokušajte prilagoditi hiperparametre (gamma, C, epsilon) prilikom kreiranja modela i procijeniti na podacima kako biste vidjeli koji skup hiperparametara daje najbolje rezultate na skupu podataka za testiranje. Za više informacija o ovim hiperparametrima, možete se referirati na dokument ovdje.
Pokušajte koristiti različite kernel funkcije za model i analizirati njihove izvedbe na skupu podataka. Koristan dokument možete pronaći ovdje.
Pokušajte koristiti različite vrijednosti za timesteps kako bi model gledao unatrag za predviđanje.

Post-lecture kviz

Pregled i samostalno učenje

Ova lekcija je bila uvod u primjenu SVR-a za predviđanje vremenskih serija. Za više informacija o SVR-u, možete se referirati na ovaj blog. Ova dokumentacija o scikit-learn pruža sveobuhvatnije objašnjenje o SVM-ovima općenito, SVR-ima i također drugim detaljima implementacije kao što su različite kernel funkcije koje se mogu koristiti, i njihovi parametri.

Zadatak

Novi SVR model

Zasluge

Odricanje od odgovornosti:
Ovaj dokument je preveden korištenjem AI usluge za prevođenje Co-op Translator. Iako nastojimo osigurati točnost, imajte na umu da automatski prijevodi mogu sadržavati pogreške ili netočnosti. Izvorni dokument na izvornom jeziku treba smatrati mjerodavnim izvorom. Za ključne informacije preporučuje se profesionalni prijevod od strane stručnjaka. Ne preuzimamo odgovornost za bilo kakve nesporazume ili pogrešne interpretacije proizašle iz korištenja ovog prijevoda.

Tekst, kod i izlaz u ovom odjeljku doprinio je @AnirbanMukherjeeXD ↩︎
Tekst, kod i izlaz u ovom odjeljku preuzet je iz ARIMA ↩︎