History

Pikachú 9fc2b847b8 updated image translation for the various languages		7 months ago
..
README.md	updated image translation for the various languages	7 months ago
assignment.md	updated image translation for the various languages	7 months ago

README.md

Zeitreihenprognose mit Support Vector Regressor

Im vorherigen Kapitel haben Sie gelernt, wie man das ARIMA-Modell zur Vorhersage von Zeitreihen verwendet. Jetzt werden wir das Modell des Support Vector Regressors betrachten, das ein Regressionsmodell ist, das verwendet wird, um kontinuierliche Daten vorherzusagen.

Vorlesungsquiz

Einführung

In dieser Lektion werden Sie eine spezifische Methode entdecken, um Modelle mit SVM: Support Vector Machine für Regression oder SVR: Support Vector Regressor zu erstellen.

SVR im Kontext von Zeitreihen ¹

Bevor wir die Bedeutung von SVR in der Zeitreihenvorhersage verstehen, sind hier einige wichtige Konzepte, die Sie kennen sollten:

Regression: Überwachtes Lernverfahren zur Vorhersage kontinuierlicher Werte aus einer gegebenen Eingabemenge. Die Idee ist, eine Kurve (oder Linie) im Merkmalsraum anzupassen, die die maximale Anzahl von Datenpunkten hat. Klicken Sie hier für weitere Informationen.
Support Vector Machine (SVM): Eine Art von überwachten maschinellen Lernmodell, das für Klassifikation, Regression und Ausreißererkennung verwendet wird. Das Modell ist ein Hyperplane im Merkmalsraum, der im Fall der Klassifikation als Grenze fungiert und im Fall der Regression als beste Anpassungslinie. Bei SVM wird in der Regel eine Kernel-Funktion verwendet, um den Datensatz in einen Raum mit höherer Dimension zu transformieren, sodass sie leichter trennbar sind. Klicken Sie hier für weitere Informationen zu SVMs.
Support Vector Regressor (SVR): Eine Art von SVM, die die beste Anpassungslinie (die im Fall von SVM ein Hyperplane ist) findet, die die maximale Anzahl von Datenpunkten hat.

Warum SVR? ¹

In der letzten Lektion haben Sie über ARIMA gelernt, das eine sehr erfolgreiche statistische lineare Methode zur Vorhersage von Zeitreihendaten ist. In vielen Fällen weisen Zeitreihendaten jedoch Nichtlinearität auf, die von linearen Modellen nicht abgebildet werden kann. In solchen Fällen macht die Fähigkeit von SVM, Nichtlinearität in den Daten für Regressionsaufgaben zu berücksichtigen, SVR erfolgreich in der Zeitreihenvorhersage.

Übung - Erstellen Sie ein SVR-Modell

Die ersten Schritte zur Datenvorbereitung sind die gleichen wie in der vorherigen Lektion über ARIMA.

Öffnen Sie den /working Ordner in dieser Lektion und finden Sie die notebook.ipynb Datei.²

Führen Sie das Notebook aus und importieren Sie die erforderlichen Bibliotheken: ²

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

Laden Sie die Daten aus der Datei /data/energy.csv in ein Pandas-DataFrame und werfen Sie einen Blick darauf: ²
```
energy = load_data('../../data')[['load']]
```

Zeichnen Sie alle verfügbaren Energiedaten von Januar 2012 bis Dezember 2014: ²

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

Jetzt lassen Sie uns unser SVR-Modell erstellen.

Erstellen Sie Trainings- und Testdatensätze

Jetzt sind Ihre Daten geladen, sodass Sie sie in Trainings- und Testdatensätze aufteilen können. Dann werden Sie die Daten umformen, um einen zeitbasierten Datensatz zu erstellen, der für das SVR benötigt wird. Sie werden Ihr Modell im Trainingssatz trainieren. Nachdem das Modell mit dem Training abgeschlossen ist, werden Sie die Genauigkeit im Trainingssatz, Testsatz und dann im vollständigen Datensatz bewerten, um die Gesamtleistung zu sehen. Sie müssen sicherstellen, dass der Testsatz einen späteren Zeitraum als der Trainingssatz abdeckt, um zu gewährleisten, dass das Modell keine Informationen aus zukünftigen Zeiträumen gewinnt ² (eine Situation, die als Überanpassung bekannt ist).

Weisen Sie einen Zeitraum von zwei Monaten vom 1. September bis 31. Oktober 2014 dem Trainingssatz zu. Der Testsatz umfasst den Zeitraum von zwei Monaten vom 1. November bis 31. Dezember 2014: ²
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```

Visualisieren Sie die Unterschiede: ²

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

Bereiten Sie die Daten für das Training vor

Jetzt müssen Sie die Daten für das Training vorbereiten, indem Sie eine Filterung und Skalierung Ihrer Daten durchführen. Filtern Sie Ihren Datensatz, um nur die benötigten Zeiträume und Spalten einzuschließen, und skalieren Sie, um sicherzustellen, dass die Daten im Intervall 0,1 projiziert werden.

Filtern Sie den ursprünglichen Datensatz, um nur die oben genannten Zeiträume pro Satz und nur die benötigte Spalte 'load' sowie das Datum einzuschließen: ²

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)

Skalieren Sie die Trainingsdaten auf den Bereich (0, 1): ²

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

Jetzt skalieren Sie die Testdaten: ²
```
test['load'] = scaler.transform(test)
```

Erstellen Sie Daten mit Zeitstempeln ¹

Für das SVR transformieren Sie die Eingabedaten in die Form [batch, timesteps]. So, you reshape the existing train_data and test_data, sodass eine neue Dimension entsteht, die sich auf die Zeitstempel bezieht.

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

Für dieses Beispiel nehmen wir timesteps = 5. Die Eingaben für das Modell sind die Daten für die ersten 4 Zeitstempel, und die Ausgabe wird die Daten für den 5. Zeitstempel sein.

timesteps=5

Konvertieren der Trainingsdaten in einen 2D-Tensor mit geschachtelter Listenverständnis:

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)

Konvertieren der Testdaten in einen 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)

Auswahl von Eingaben und Ausgaben aus den Trainings- und Testdaten:

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)

Implementieren Sie SVR ¹

Jetzt ist es Zeit, SVR zu implementieren. Um mehr über diese Implementierung zu erfahren, können Sie auf diese Dokumentation verweisen. Für unsere Implementierung folgen wir diesen Schritten:

Definieren Sie das Modell, indem Sie die Funktion SVR() and passing in the model hyperparameters: kernel, gamma, c and epsilon
Prepare the model for the training data by calling the fit() function
Make predictions calling the predict() aufrufen.

Jetzt erstellen wir ein SVR-Modell. Hier verwenden wir den RBF-Kernel und setzen die Hyperparameter gamma, C und epsilon auf 0.5, 10 und 0.05.

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

Modell an den Trainingsdaten anpassen ¹

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)

Vorhersagen des Modells machen ¹

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)

Sie haben Ihr SVR erstellt! Jetzt müssen wir es bewerten.

Bewerten Sie Ihr Modell ¹

Zur Bewertung werden wir zunächst die Daten auf unsere ursprüngliche Skala zurückskalieren. Dann, um die Leistung zu überprüfen, werden wir das ursprüngliche und das vorhergesagte Zeitreihendiagramm zeichnen und auch das MAPE-Ergebnis ausgeben.

Skalieren Sie die vorhergesagte und die ursprüngliche Ausgabe:

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

Überprüfen Sie die Modellleistung auf Trainings- und Testdaten ¹

Wir extrahieren die Zeitstempel aus dem Datensatz, um sie auf der x-Achse unseres Diagramms anzuzeigen. Beachten Sie, dass wir die ersten timesteps-1 Werte als Eingabe für die erste Ausgabe verwenden, sodass die Zeitstempel für die Ausgabe danach beginnen.

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

Zeichnen Sie die Vorhersagen für die Trainingsdaten:

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

Geben Sie MAPE für die Trainingsdaten aus

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

MAPE for training data: 1.7195710200875551 %

Zeichnen Sie die Vorhersagen für die Testdaten

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

Geben Sie MAPE für die Testdaten aus

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

MAPE for testing data:  1.2623790187854018 %

🏆 Sie haben ein sehr gutes Ergebnis im Testsatz erzielt!

Überprüfen Sie die Modellleistung auf dem vollständigen Datensatz ¹

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

🏆 Sehr schöne Plots, die ein Modell mit guter Genauigkeit zeigen. Gut gemacht!

🚀Herausforderung

Versuchen Sie, die Hyperparameter (gamma, C, epsilon) beim Erstellen des Modells anzupassen und bewerten Sie die Daten, um zu sehen, welche Kombination von Hyperparametern die besten Ergebnisse im Testsatz liefert. Um mehr über diese Hyperparameter zu erfahren, können Sie auf das Dokument hier verweisen.
Versuchen Sie, verschiedene Kernel-Funktionen für das Modell zu verwenden und analysieren Sie deren Leistung im Datensatz. Ein hilfreiches Dokument finden Sie hier.
Versuchen Sie, verschiedene Werte für timesteps für das Modell zu verwenden, um eine Rückschau zu machen und Vorhersagen zu treffen.

Nachlesungsquiz

Überprüfung & Selbststudium

Diese Lektion sollte die Anwendung von SVR für Zeitreihenprognosen einführen. Um mehr über SVR zu erfahren, können Sie auf diesen Blog verweisen. Diese Dokumentation zu scikit-learn bietet eine umfassendere Erklärung zu SVMs im Allgemeinen, SVRs und auch andere Implementierungsdetails wie die verschiedenen Kernel-Funktionen, die verwendet werden können, sowie deren Parameter.

Aufgabe

Ein neues SVR-Modell

Credits

Haftungsausschluss:
Dieses Dokument wurde mit maschinellen KI-Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, bitten wir zu beachten, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als die maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Verwendung dieser Übersetzung entstehen.

Der Text, der Code und die Ausgabe in diesem Abschnitt wurden von @AnirbanMukherjeeXD beigesteuert. ↩︎
Der Text, der Code und die Ausgabe in diesem Abschnitt stammen von ARIMA ↩︎