如何使用XGBoost和InluxDB进行时间序列预测

import "join"

import "influxdata/influxdb/sample"

//dataset is regular time series at 10 second intervals

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

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

import "join"

import "influxdata/influxdb/sample"

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

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

shiftedData = data

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

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

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

import "experimental"

import "influxdata/influxdb/sample"

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

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



shiftedData1 = data

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

|> set(key: "shift" , value: "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])

|> pivot(rowKey:["_time"], columnKey: ["shift"], valueColumn: "_value")

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

// remove the NaN values

|> limit(n:360)

|> tail(n: 356)

import pandas as pd

from numpy import asarray

from sklearn.metrics import mean_absolute_error

from xgboost import XGBRegressor

from matplotlib import pyplot

from influxdb_client import InfluxDBClient

from influxdb_client.client.write_api import SYNCHRONOUS



# query data with the Python InfluxDB Client Library and transform data into a supervised learning problem with Flux

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" and r.sensor_id == "TLM0100")'

'shiftedData = data'

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

'join.time(left: data, right: shiftedData, as: (l, r) => ({l with data: l._value, shiftedData: r._value}))'

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

  '|> yield(name: "converted to supervised learning dataset")'

)

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

data = df.to_numpy()



# split a univariate dataset into train/test sets

def train_test_split(data, n_test):

     return data[:-n_test:], data[-n_test:]



# fit an xgboost model and make a one step prediction

def xgboost_forecast(train, testX):

     # transform list into array

     train = asarray(train)

     # split into input and output columns

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

     # fit model

     model = XGBRegressor(objective='reg:squarederror', n_estimators=1000)

     model.fit(trainX, trainy)

     # make a one-step prediction

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

     return yhat[0]



# walk-forward validation for univariate data

def walk_forward_validation(data, n_test):

     predictions = list()

     # split dataset

     train, test = train_test_split(data, n_test)

     history = [x for x in train]

     # step over each time-step in the test set

     for i in range(len(test)):

          # split test row into input and output columns

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

          # fit model on history and make a prediction

          yhat = xgboost_forecast(history, testX)

          # store forecast in list of predictions

          predictions.append(yhat)

          # add actual observation to history for the next loop

          history.append(test[i])

          # summarize progress

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

     # estimate prediction error

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

     return error, test[:, -1], predictions



# evaluate

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

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



# plot expected vs predicted

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

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

pyplot.legend()

pyplot.show()