So verwenden Sie XGBoost und InluxDB für die Zeitreihenvorhersage

XGBoost ist eine beliebte Open-Source-Bibliothek für maschinelles Lernen, mit der verschiedene Vorhersageprobleme gelöst werden können. Man muss verstehen, wie man es mit InfluxDB für Zeitreihenprognosen verwendet.

Übersetzer |. Li Rui

Reviewer |. XGBoost verwendet Parallelverarbeitung für eine schnelle Leistung, verarbeitet fehlende Werte gut, bietet eine gute Leistung bei kleinen Datensätzen und verhindert eine Überanpassung. All diese Vorteile machen XGBoost zu einer beliebten Lösung für Regressionsprobleme wie Vorhersagen.

Prognosen sind für verschiedene Geschäftsziele wie Predictive Analytics, Predictive Maintenance, Produktplanung, Budgetierung usw. von entscheidender Bedeutung. Viele Prognosen oder Prognoseprobleme betreffen Zeitreihendaten. Dies macht XGBoost zu einem hervorragenden Partner für die Open-Source-Zeitreihendatenbank InfluxDB.

In diesem Tutorial erfahren Sie, wie Sie das Python-Paket von XGBoost verwenden, um Daten aus der InfluxDB-Zeitreihendatenbank vorherzusagen. Sie werden außerdem die InfluxDB-Python-Clientbibliothek verwenden, um Daten von InfluxDB abzufragen und die Daten in einen Pandas DataFrame zu konvertieren, um die Arbeit mit Zeitreihendaten vor der Erstellung von Vorhersagen zu erleichtern. Darüber hinaus werden die Vorteile von XGBoost genauer besprochen.

1. Anforderungen

Dieses Tutorial wird auf einem macOS-System durchgeführt, auf dem Python 3 über Homebrew installiert ist. Es wird empfohlen, zusätzliche Tools wie virtualenv, pyenv oder conda-env einzurichten, um die Python- und Client-Installation zu vereinfachen. Ansonsten sind alle Anforderungen wie folgt:

influxdb-client = 1.30.0

• pandas = 1.4.3
• xgboost & gt; = 1.7.3
• influxdb-client & gt; = 1.30.0
• pandas & gt; = 1.4.3
• matplotlib>=3.5.2
• sklearn>=1.1.1
• Dieses Tutorial setzt außerdem ein kostenloses InfluxDB-Cloud-Konto voraus und dass ein Bucket und ein Token erstellt wurden Der Bucket ist die Struktur der höchsten Ebene für die Datenorganisation in einer Datenbank oder InfluxDB. In diesem Tutorial wird ein Bucket mit dem Namen NOAA erstellt.

2. Entscheidungsbäume, Random Forests und Gradient Boosting

Um zu verstehen, was XGBoost ist, müssen Sie Entscheidungsbäume, Random Forests und Gradient Boosting verstehen. Entscheidungsbäume sind eine überwachte Lernmethode, die aus einer Reihe von Funktionstests besteht. Jeder Knoten ist ein Test und alle Knoten sind in einer Flussdiagrammstruktur organisiert. Zweige stellen Bedingungen dar, die letztendlich bestimmen, welche Blattbezeichnung oder Klassenbezeichnung den Eingabedaten zugewiesen wird.

Entscheidungsbäume im maschinellen Lernen werden verwendet, um festzustellen, ob es morgen regnen wird. Bearbeitet, um die Komponenten eines Entscheidungsbaums anzuzeigen: Blätter, Zweige und Knoten.

Das Leitprinzip hinter Entscheidungsbäumen, Random Forests und Gradient Boosting besteht darin, dass mehrere „schwache Lernende“ oder Klassifikatoren zusammenarbeiten, um starke Vorhersagen zu treffen.

Zufälliger Wald enthält mehrere Entscheidungsbäume. Jeder Knoten in einem Entscheidungsbaum wird als schwacher Lernender betrachtet, und jeder Entscheidungsbaum in einer Zufallsstruktur wird als einer von vielen schwachen Lernenden in einem Zufallswaldmodell betrachtet. Typischerweise werden alle Daten zufällig in Teilmengen aufgeteilt und durch verschiedene Entscheidungsbäume geleitet.

Gradient Boosting mithilfe von Entscheidungsbäumen und Zufallswäldern ist ähnlich, aber die Art und Weise, wie sie strukturiert sind, ist unterschiedlich. Gradientenverstärkte Bäume enthalten auch Entscheidungsbaumwälder, aber diese Entscheidungsbäume werden zusätzlich konstruiert und alle Daten werden durch ein Ensemble von Entscheidungsbäumen geleitet. Gradientenverstärkungsbäume können aus einer Reihe von Klassifizierungsbäumen oder Regressionsbäumen bestehen, mit Klassifizierungsbäumen für diskrete Werte (z. B. Katzen oder Hunde). Für kontinuierliche Werte (z. B. 0 bis 100) werden Regressionsbäume verwendet.

3. Was ist XGBoost?

Gradient Boosting ist ein maschineller Lernalgorithmus zur Klassifizierung und Vorhersage. XGBoost ist lediglich eine extreme Art der Gradientenverstärkung. Im Extremfall kann die Gradientenverstärkung durch die Leistungsfähigkeit der Parallelverarbeitung effizienter durchgeführt werden. Das folgende Bild aus der XGBoost-Dokumentation zeigt, wie Gradient Boosting verwendet werden kann, um vorherzusagen, ob jemandem ein Videospiel gefallen wird.

Zwei Entscheidungsbäume werden verwendet, um zu entscheiden, ob jemandem ein Videospiel gefallen wird. Addieren Sie die Blattwerte beider Bäume, um zu bestimmen, welche Person das Videospiel am wahrscheinlichsten genießen wird.

Einige Vorteile von XGBoost:

Relativ einfach zu verstehen.

• Geeignet für kleine, strukturierte und regelmäßige Daten mit wenigen Funktionen.
• Einige Nachteile von XGBoost:

• Leicht zu überpassend und empfindlich gegenüber Ausreißern. Es könnte eine gute Idee sein, materialisierte Ansichten von Zeitreihendaten in XGBoost für Prognosen zu verwenden.
• Schlechte Leistung bei spärlichen oder unbeaufsichtigten Daten.

4. Verwenden Sie XGBoost für die Zeitreihenvorhersage

Der hier verwendete Luftsensor-Beispieldatensatz wird von InfluxDB bereitgestellt. Dieser Datensatz enthält Temperaturdaten von mehreren Sensoren. Für einen einzelnen Sensor wird eine Temperaturvorhersage mit Daten wie diesen erstellt:

Verwenden Sie den folgenden Flux-Code, um den Datensatz zu importieren und für eine einzelne Zeitreihe zu filtern. (Flux ist die Abfragesprache von InfluxDB). " )

|> filter(fn: (r) => r._field == "temperature" and r.sensor_id == "TLM0100")


Zufällige Wald- und Gradientenverstärkung kann für die Zeitreihenvorhersage verwendet werden , aber Sie erfordern die Umwandlung von Daten in überwachtes Lernen. Dies bedeutet, dass die Daten in einem gleitenden Fensteransatz oder einem langsamen Ansatz vorwärts bewegt werden müssen, um die Zeitreihendaten in einen überwachten Lernsatz umzuwandeln. Die Daten können auch mit Flux vorbereitet werden. Idealerweise sollte zunächst eine Autokorrelationsanalyse durchgeführt werden, um die beste Methode zu ermitteln. Der Kürze halber wird der folgende Flux-Code verwendet, um Daten in regelmäßigen Abständen zu verschieben.

import „join“

import „influxdata/influxdb/sample“
data = sample.data(set: „airSensor“)

|> filter(fn: (r) => r._field == "temperature" und r.sensor_id == "TLM0100")

shiftedData = data

|> timeShift(duration: 10s , columns: ["_time"] )

join.time(left: data, right:shiftedData , as: (l, r) => ({l mit Daten: l._value, verschobene Daten: r._value}))

|> drop(columns: ["_measurement", "_time", "_value" , „sensor_id“, „_field“])


Wischen Sie nach links oder rechts, um den vollständigen Code anzuzeigen




Wenn Sie der Modelleingabe zusätzliche Verzögerungsdaten hinzufügen möchten, können Sie stattdessen der folgenden Flux-Logik folgen.

import „experimental“

import „influxdata/influxdb/sample“

data = sample.data(set: „airSensor“)

|> filter(fn: (r) => r._field == "temperature" und r.sensor_id == "TLM0100")

shiftedData1 = data

|> timeShift(duration: 10s , columns: ["_time"] )

|> set(key: "shift " , Wert: "1" )



shiftedData2 = data

|> timeShift(duration: 20s , columns: ["_time"] )

|> set(key: "shift" , value: " 2" )



shiftedData3 = data

|> timeShift(duration: 30s , columns: ["_time"] )

|> set(key: "shift" , value: "3")



shiftedData4 = data

|> timeShift(duration: 40s , columns: ["_time"] )

|> set(key: "shift" , value: "4")



union(tables : [shiftedData1,shiftedData2,shiftedData3,shiftedData4])

|> "_measurement", "_time", "_value", "sensor_id", "_field"])

// die NaN-Werte entfernen

|> limit(n:360)

|> )


Außerdem müssen wir die Vorwärtsvalidierung verwenden, um den Algorithmus zu trainieren. Dabei wird der Datensatz in einen Testsatz und einen Trainingssatz aufgeteilt. Verwenden Sie dann den XGB-Regressor, um das XGBoost-Modell zu trainieren und die Anpassungsmethode zur Vorhersage zu verwenden. Schließlich verwenden wir den mittleren absoluten Fehler (MAE), um die Genauigkeit der Prognose zu bestimmen. Bei einer Verzögerung von 10 Sekunden beträgt der berechnete mittlere absolute Fehler (MAE) 0,035. Wir können dies so interpretieren, dass 96,5 % der Vorhersagen sehr richtig sind. Die folgende Abbildung zeigt den Vergleich zwischen den Vorhersagen, die wir von XGBoost erhalten, und den erwarteten Werten aus der Zug-/Testaufteilung.




Das Folgende ist das vollständige Skript. Dieser Code stammt größtenteils aus dem Tutorial hier.
Pandas als PD importieren influxdb_client.client.write_api import SYNCHRONOUS

# Fragen Sie Daten mit der Python InfluxDB-Clientbibliothek ab und verwandeln Sie Daten mit Flux in ein überwachtes Lernproblem.

client = InfluxDBClient(url="https://us-west-2-1.aws.cloud2.influxdata.com", token="NyP-HzFGkObUBI4Wwg6Rbd-_SdrTMtZzbFK921VkMQWp3bv_e9BhpBi6fCBr_0-6i0ev32_XWZcmkDPsearTWA==", org="0437f6d51b579000")



# write_api = client.write_api(write_optinotallow=SYNCHRONOUS)

query_api = client.query_api()

df = query_api. query_data_frame('import "join"'

'import "influxdata/influxdb/sample"'

'data = sample.data(set: "airSensor")'

'|> filter(fn: (r) = > r._field == "temperature" und r.sensor_id == "TLM0100")'

'shiftedData = data'

'|> timeShift(duration: 10s , columns: ["_time"] )'

'join.time(links: Daten, rechts: verschobene Daten, as: (l, r) => ({l mit Daten: l._value, verschobene Daten: r._value}))'

'|> drop(columns: ["_measurement", "_time", "_value", "sensor_id", "_field"])'

'|> yield(name: "in überwachten Lerndatensatz konvertiert")'

)

df = df.drop(columns=['table', 'result'])

data = df.to_numpy()



# Teilen Sie einen univariaten Datensatz in Trainings-/Testsätze auf Vorhersage

def xgboost_forecast(train, testX):

# Liste in Array umwandeln

train = asarray(train)

# in Eingabe- und Ausgabespalten aufteilen

trainX, trainy = train[:, :-1], train[:, -1]

# Modell anpassen

model =
yhat = model.predict(asarray([testX]))

return yhat[0]



# Walk-Forward-Validierung für univariate Daten

def walk_forward_validation(data, n_test):

Predictions = list()

# geteilter Datensatz

train, test = train_test_split(data, n_test)

History = [x für test)):

# Testzeile in Eingabe- und Ausgabespalten aufteilen

testX, testy = test[i, :-1], test[i, -1]

# Modell an den Verlauf anpassen und eine Vorhersage treffen

yhat = xgboost_forecast(history, testX)

# Prognose in der Liste der Vorhersagen speichern

predictions.append(yhat)

# Tatsächliche Beobachtung zum Verlauf für die nächste Schleife hinzufügen

history.append(test[i])

# Fortschritt zusammenfassen

print('>expected=%.1f, Predicted=%.1f' % (testy, yhat))

# Vorhersagefehler schätzen

error = mean_absolute_error(test[:, -1], Vorhersagen )

Fehler zurückgeben, Test[:, -1], Vorhersagen



# bewerten

mae, y, yhat = walk_forward_validation(data, 100)

print('MAE: %.3f' % mae)



# Plot erwartet vs. vorhergesagt

pyplot.plot(y, label='Expected')

pyplot.plot(yhat, label='Predicted')

pyplot.legend()

pyplot.show()


五、结论

希望这篇博文能够激励人们利用XGBoost和InfluxDB进行预测。为此建议查看相关的报告, 其中包括如何使用本文描述的许多算法和InfluxDB来进行预测和执行异常检测的示例。

原文链接：https://www.infoworld.com/article/3682070/time-series-forecasting-with-xgboost-and-influxdb.html

Das obige ist der detaillierte Inhalt vonSo verwenden Sie XGBoost und InluxDB für die Zeitreihenvorhersage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!