History

leestott e4050807fb 🌐 Update translations via Co-op Translator		3 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	3 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	3 weeks ago

README.md

Aikasarjojen ennustaminen Support Vector Regressor -mallilla

Edellisessä osiossa opit käyttämään ARIMA-mallia aikasarjojen ennustamiseen. Nyt tutustut Support Vector Regressor -malliin, joka on regressiomalli jatkuvien arvojen ennustamiseen.

Ennakkovisa

Johdanto

Tässä osiossa opit rakentamaan malleja käyttäen SVM: Support Vector Machine -menetelmää regressiotehtäviin, eli SVR: Support Vector Regressor.

SVR aikasarjojen yhteydessä ¹

Ennen kuin ymmärrät SVR:n merkityksen aikasarjojen ennustamisessa, on tärkeää tuntea seuraavat käsitteet:

Regressio: Ohjattu oppimismenetelmä, jolla ennustetaan jatkuvia arvoja annetusta syötedatasta. Tavoitteena on sovittaa käyrä (tai viiva) piirreavaruuteen siten, että se sisältää mahdollisimman monta datapistettä. Lisätietoa.
Support Vector Machine (SVM): Ohjattu koneoppimismalli, jota käytetään luokitteluun, regressioon ja poikkeamien tunnistamiseen. Malli muodostaa hypertason piirreavaruuteen, joka toimii luokittelussa rajana ja regressiossa parhaana sovitusviivana. SVM:ssä käytetään yleensä ydinfunktiota (Kernel), joka muuntaa datan korkeampaan ulottuvuuteen, jotta se olisi helpommin eroteltavissa. Lisätietoa.
Support Vector Regressor (SVR): SVM:n tyyppi, joka etsii parhaan sovitusviivan (SVM:n tapauksessa hypertason), joka sisältää mahdollisimman monta datapistettä.

Miksi SVR? ¹

Edellisessä osiossa opit ARIMA-mallista, joka on erittäin menestyksekäs tilastollinen lineaarinen menetelmä aikasarjojen ennustamiseen. Kuitenkin monissa tapauksissa aikasarjadatassa on epälineaarisuutta, jota lineaariset mallit eivät pysty mallintamaan. Tällaisissa tilanteissa SVM:n kyky huomioida epälineaarisuus tekee SVR:stä menestyksekkään aikasarjojen ennustamisessa.

Harjoitus - rakenna SVR-malli

Ensimmäiset vaiheet datan valmistelussa ovat samat kuin edellisessä ARIMA-osiossa.

Avaa tämän osion /working -kansio ja etsi notebook.ipynb -tiedosto.²

Suorita notebook ja tuo tarvittavat kirjastot: ²

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

Lataa data /data/energy.csv -tiedostosta Pandas-dataframeen ja tarkastele sitä: ²
```
energy = load_data('../../data')[['load']]
```

Piirrä kaikki saatavilla oleva energiadata tammikuusta 2012 joulukuuhun 2014: ²

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

Nyt rakennetaan SVR-malli.

Luo harjoitus- ja testidatasetit

Kun data on ladattu, jaa se harjoitus- ja testidatasetteihin. Muotoile data aikaväleihin perustuvaksi datasetiksi, jota tarvitaan SVR:ää varten. Koulutat mallin harjoitusdatalla. Kun malli on koulutettu, arvioit sen tarkkuutta harjoitusdatalla, testidatalla ja koko datasetillä nähdäksesi kokonaisvaltaisen suorituskyvyn. Varmista, että testidata kattaa ajanjakson, joka on harjoitusdatan jälkeinen, jotta malli ei saa tietoa tulevista ajanjaksoista ² (tilanne, jota kutsutaan ylisovittamiseksi).

Allokoi kahden kuukauden ajanjakso 1. syyskuuta - 31. lokakuuta 2014 harjoitusdataksi. Testidata sisältää kahden kuukauden ajanjakson 1. marraskuuta - 31. joulukuuta 2014: ²
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```

Visualisoi erot: ²

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

Valmistele data koulutusta varten

Nyt sinun täytyy valmistella data koulutusta varten suodattamalla ja skaalaamalla se. Suodata datasetti sisältämään vain tarvittavat ajanjaksot ja sarakkeet, ja skaalaa data välille 0,1.

Suodata alkuperäinen datasetti sisältämään vain edellä mainitut ajanjaksot ja tarvittava sarake 'load' sekä päivämäärä: ²

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)

Skaalaa harjoitusdata välille (0, 1): ²

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

Skaalaa nyt testidata: ²
```
test['load'] = scaler.transform(test)
```

Luo data aikaväleillä ¹

SVR:ää varten muunnat syötteen muotoon [batch, timesteps]. Muotoile olemassa oleva train_data ja test_data siten, että niihin lisätään uusi ulottuvuus, joka viittaa aikaväleihin.

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

Tässä esimerkissä otetaan timesteps = 5. Mallin syötteet ovat ensimmäisten neljän aikavälin data, ja ulostulo on viidennen aikavälin data.

timesteps=5

Muunna harjoitusdata 2D-tensoriksi käyttäen sisäkkäistä listan ymmärrystä:

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)

Muunna testidata 2D-tensoriksi:

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)

Valitse syötteet ja ulostulot harjoitus- ja testidatasta:

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)

Toteuta SVR ¹

Nyt on aika toteuttaa SVR. Lisätietoa toteutuksesta löydät tästä dokumentaatiosta. Toteutuksessa noudatetaan seuraavia vaiheita:

Määrittele malli kutsumalla SVR() ja syöttämällä mallin hyperparametrit: kernel, gamma, c ja epsilon
Valmistele malli harjoitusdataa varten kutsumalla fit()-funktiota
Tee ennusteita kutsumalla predict()-funktiota

Nyt luodaan SVR-malli. Tässä käytetään RBF-ydintä, ja asetetaan hyperparametrit gamma, C ja epsilon arvoihin 0.5, 10 ja 0.05.

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

Sovita malli harjoitusdataan ¹

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)

Tee malliennusteita ¹

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)

Olet rakentanut SVR-mallin! Nyt arvioidaan sen suorituskykyä.

Arvioi mallisi ¹

Arviointia varten skaalaamme datan takaisin alkuperäiseen mittakaavaan. Suorituskyvyn tarkistamiseksi piirrämme alkuperäisen ja ennustetun aikasarjan sekä tulostamme MAPE-tuloksen.

Skaalaa ennustettu ja alkuperäinen ulostulo:

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

Tarkista mallin suorituskyky harjoitus- ja testidatalla ¹

Poimimme aikaleimat datasetistä, jotta ne voidaan näyttää x-akselilla. Huomaa, että käytämme ensimmäisiä timesteps-1 arvoja ensimmäisen ulostulon syötteenä, joten ulostulon aikaleimat alkavat vasta sen jälkeen.

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

Piirrä ennusteet harjoitusdatasta:

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

Tulosta MAPE harjoitusdatasta

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

MAPE for training data: 1.7195710200875551 %

Piirrä ennusteet testidatasta

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

Tulosta MAPE testidatasta

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

MAPE for testing data:  1.2623790187854018 %

🏆 Sait erittäin hyvän tuloksen testidatalla!

Tarkista mallin suorituskyky koko datasetillä ¹

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

🏆 Erittäin hienot kaaviot, jotka osoittavat mallin hyvän tarkkuuden. Hyvin tehty!

🚀Haaste

Kokeile säätää hyperparametreja (gamma, C, epsilon) mallia luodessasi ja arvioi niiden vaikutusta testidatan tuloksiin. Lisätietoa hyperparametreista löydät täältä.
Kokeile käyttää erilaisia ydinfunktioita mallissa ja analysoi niiden suorituskykyä datasetillä. Hyödyllinen dokumentti löytyy täältä.
Kokeile käyttää erilaisia timesteps-arvoja, jotta malli voi katsoa taaksepäin ennustetta tehdessään.

Jälkivisa

Kertaus ja itseopiskelu

Tässä osiossa esiteltiin SVR:n käyttö aikasarjojen ennustamiseen. Lisätietoa SVR:stä löydät tästä blogista. Tämä scikit-learn-dokumentaatio tarjoaa kattavamman selityksen SVM:stä yleisesti, SVR:stä ja muista toteutuksen yksityiskohdista, kuten eri ydinfunktioista ja niiden parametreista.

Tehtävä

Uusi SVR-malli

Kiitokset

Vastuuvapauslauseke:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua Co-op Translator. Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.

Tämän osion teksti, koodi ja tulokset on kirjoittanut @AnirbanMukherjeeXD ↩︎
Tämän osion teksti, koodi ja tulokset on otettu ARIMA -osiosta ↩︎