Comment utiliser XGBoost et InluxDB pour la prévision de séries chronologiques

XGBoost est une bibliothèque d'apprentissage automatique open source populaire qui peut être utilisée pour résoudre divers problèmes de prédiction. Il faut comprendre comment l'utiliser avec InfluxDB pour la prévision de séries chronologiques.

Traducteur | Li Rui

Reviewer | Sun Shujuan

XGBoost est une bibliothèque d'apprentissage automatique open source qui implémente un algorithme d'augmentation de gradient distribué optimisé. XGBoost utilise le traitement parallèle pour des performances rapides, gère bien les valeurs manquantes, fonctionne bien sur de petits ensembles de données et empêche le surajustement. Tous ces avantages font de XGBoost une solution populaire pour les problèmes de régression tels que la prédiction.

La prévision est essentielle à la mission pour divers objectifs commerciaux tels que l'analyse prédictive, la maintenance prédictive, la planification des produits, la budgétisation, etc. De nombreux problèmes de prévision ou de prévision impliquent des données de séries chronologiques. Cela fait de XGBoost un excellent partenaire pour la base de données de séries chronologiques open source InfluxDB.

Ce tutoriel apprendra comment utiliser le package Python de XGBoost pour prédire les données de la base de données de séries chronologiques InfluxDB. Vous utiliserez également la bibliothèque client InfluxDB Python pour interroger les données d'InfluxDB et convertir les données en Pandas DataFrame afin de faciliter l'utilisation des données de séries chronologiques avant de faire des prédictions. De plus, les avantages de XGBoost seront discutés plus en détail.

1. Exigences

Ce tutoriel est réalisé sur un système macOS avec Python 3 installé via Homebrew. Il est recommandé de configurer des outils supplémentaires tels que virtualenv, pyenv ou conda-env pour simplifier l'installation de Python et du client. Sinon, toutes ses exigences sont les suivantes :

• influxdb-client = 1.30.0
• pandas = 1.4.3
• xgboost & gt; pandas & gt; = 1.4.3
• matplotlib>=3.5.2
• sklearn>=1.1.1
• Ce tutoriel suppose également un compte cloud InfluxDB de niveau gratuit et qu'un bucket et un jeton ont été créés, pensez à le bucket est la structure de niveau le plus élevé pour l'organisation des données dans une base de données ou InfluxDB. Dans ce didacticiel, un bucket nommé NOAA sera créé.
• 2. Arbres de décision, forêts aléatoires et amélioration du gradient

Afin de comprendre ce qu'est XGBoost, vous devez comprendre les arbres de décision, les forêts aléatoires et l'amélioration du gradient. Les arbres de décision sont une méthode d'apprentissage supervisé composée d'une série de tests de fonctionnalités. Chaque nœud est un test et tous les nœuds sont organisés dans une structure d'organigramme. Les branches représentent des conditions qui déterminent en fin de compte quelle étiquette de feuille ou quelle étiquette de classe est attribuée aux données d'entrée.

Les arbres de décision en apprentissage automatique sont utilisés pour déterminer s'il pleuvra demain. Modifié pour afficher les composants d'un arbre de décision : feuilles, branches et nœuds.

Le principe directeur derrière les arbres de décision, les forêts aléatoires et l'augmentation des gradients est que plusieurs « apprenants faibles » ou classificateurs travaillent ensemble pour faire des prédictions solides.

La forêt aléatoire contient plusieurs arbres de décision. Chaque nœud d'un arbre de décision est considéré comme un apprenant faible, et chaque arbre de décision dans une forêt aléatoire est considéré comme l'un des nombreux apprenants faibles dans un modèle de forêt aléatoire. En règle générale, toutes les données sont divisées de manière aléatoire en sous-ensembles et transmises via différents arbres de décision.

L'augmentation des dégradés à l'aide d'arbres de décision et de forêts aléatoires est similaire, mais la façon dont ils sont structurés est différente. Les arbres améliorés par gradient contiennent également des forêts d'arbres de décision, mais ces arbres de décision sont en outre construits et toutes les données sont transmises à travers un ensemble d'arbres de décision. Les arbres d'augmentation de gradient peuvent consister en un ensemble d'arbres de classification ou d'arbres de régression, avec des arbres de classification pour des valeurs discrètes (telles que les chats ou les chiens). Les arbres de régression sont utilisés pour les valeurs continues (par exemple 0 à 100).

3. Qu'est-ce que XGBoost ?

Gradient boosting est un algorithme d'apprentissage automatique pour la classification et la prédiction. XGBoost n'est qu'un type extrême d'amélioration de dégradé. À l’extrême, l’augmentation du gradient peut être réalisée plus efficacement grâce à la puissance du traitement parallèle. L'image ci-dessous tirée de la documentation XGBoost illustre comment l'augmentation du gradient peut être utilisée pour prédire si quelqu'un aimera un jeu vidéo.

Deux arbres de décision sont utilisés pour décider si quelqu'un est susceptible d'aimer un jeu vidéo. Additionnez les scores des feuilles des deux arbres pour déterminer quelle personne est la plus susceptible d’apprécier le jeu vidéo.

Quelques avantages de XGBoost :

Relativement facile à comprendre.

Convient aux petites données structurées et régulières avec peu de fonctionnalités.

• Quelques inconvénients de XGBoost :
• • Facile au surapprentissage et sensible aux valeurs aberrantes. Cela pourrait être une bonne idée d'utiliser des vues matérialisées de données de séries chronologiques dans XGBoost à des fins de prévision.
  • Fonctionne mal sur des données clairsemées ou non supervisées.

  4. Utilisez XGBoost pour la prédiction de séries chronologiques

  L'ensemble de données d'échantillons de capteurs d'air utilisé ici est fourni par InfluxDB. Cet ensemble de données contient des données de température provenant de plusieurs capteurs. Une prévision de température est en cours de création pour un seul capteur avec des données comme celles-ci :

  

  Utilisez le code Flux suivant pour importer l'ensemble de données et filtrer pour une seule série temporelle. (Flux est le langage de requête d'InfluxDB)

  import "join"
  
  import "influxdata/influxdb/sample"
  
  //dataset est une série temporelle régulière à 10 secondes d'intervalle
  
  data = sample.data(set: "airSensor " )
  
  |> filter(fn: (r) => r._field == "temperature" et r.sensor_id == "TLM0100")

  La forêt aléatoire et l'amplification de gradient peuvent être utilisées pour la prédiction de séries chronologiques , mais ils nécessitent de transformer les données en apprentissage supervisé. Cela signifie que les données doivent être avancées selon une approche de fenêtre glissante ou une approche lente pour convertir les données de séries chronologiques en un ensemble d'apprentissage supervisé. Les données peuvent également être préparées avec Flux. Idéalement, une analyse d’autocorrélation devrait d’abord être effectuée pour déterminer la meilleure méthode à utiliser. Par souci de concision, le code Flux suivant sera utilisé pour déplacer les données à intervalle régulier.

  import "join"
  
  import "influxdata/influxdb/sample"
  
  data = sample.data(set: "airSensor")
  
  |> filter(fn: (r) => r._field == "température" et r.sensor_id == "TLM0100")
  
  shiftedData = data
  
  |> timeShift(durée : 10s, colonnes : ["_time"] )
  
  join.time(gauche : données, droite : shiftedData , comme : (l, r) => ({l avec données : l._value, shiftedData : r._value}))
  
  |> drop(colonnes : ["_measurement", "_time", "_value" , "sensor_id", "_field"])

  Faites glisser votre doigt vers la gauche ou la droite pour afficher le code complet

  

  Si vous souhaitez ajouter des données de décalage supplémentaires à l'entrée du modèle, vous pouvez plutôt suivre la logique Flux suivante.

  import "experimental"
  
  import "influxdata/influxdb/sample"
  
  data = sample.data(set: "airSensor")
  
  |> filter(fn: (r) => r._field == "température" et r.sensor_id == "TLM0100")
  
  
  
  shiftedData1 = data
  
  |> timeShift(durée : 10 s, colonnes : ["_time"] )
  
  |> " , valeur : "1" )
  
  
  
  shiftedData2 = data
  
  |> timeShift(durée : 20s , colonnes : ["_time"] )
  
  |> set(clé : "shift" , valeur : " 2" )
  
  
  
  shiftedData3 = data
  
  |> timeShift(durée : 30s, colonnes : ["_time"] )
  
  |> set(clé : "shift", valeur : "3")
  
  
  
  shiftedData4 = data
  
  |> timeShift(durée : 40s, colonnes : ["_time"] )
  
  |> set(clé : "shift" , valeur : "4")
  
  
  
  union(tables : [shiftedData1, shiftedData2, shiftedData3, shiftedData4])
  
  |> pivot(rowKey:["_time"], columnKey: ["shift"], valueColumn: "_value")
  
  |> "_measurement", "_time", "_value", "sensor_id", "_field"])
  
  // supprimer les valeurs NaN
  
  |> limite(n:360)
  
  |> )

  De plus, nous devons utiliser la validation directe pour entraîner l'algorithme. Cela implique de diviser l'ensemble de données en un ensemble de test et un ensemble de formation. Utilisez ensuite XGB Regressor pour entraîner le modèle XGBoost et utilisez la méthode d'ajustement pour prédire. Enfin, nous utilisons l'erreur absolue moyenne (MAE) pour déterminer l'exactitude de la prévision. Pour un délai de 10 secondes, l'erreur absolue moyenne (MAE) calculée est de 0,035. Nous pouvons interpréter cela comme signifiant que 96,5 % des prédictions sont très correctes. La figure ci-dessous montre la comparaison entre les prédictions que nous obtenons de XGBoost et les valeurs attendues de la répartition train/test.

  

  Ce qui suit est le script complet. Ce code est principalement tiré du tutoriel ici.

  importer des pandas en tant que pd
  
  depuis numpy importer asarray
  
  depuis sklearn.metrics importer mean_absolute_error
  
  depuis xgboost importer XGBRegressor
  
  depuis matplotlib importer pyplot
  
  depuis influxdb_client importer InfluxDBClient
  
  from in fluxdb_client.client.write_api import SYNCHRONE
  
  
  
  # interrogez des données avec la bibliothèque client Python InfluxDB et transformez les données en un problème d'apprentissage supervisé avec 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 == "température" et r.sensor_id == "TLM0100")'
  
  'shiftedData = data'
  
  '|> timeShift(durée : 10s, colonnes : ["_time"] )'
  
  'join.time(gauche : data, droite : shiftedData, as : (l, r) => ({l avec data : l._value, shiftedData : r._value}))'
  
  '|> drop(colonnes : ["_measurement", "_time", "_value", "sensor_id", "_field"])'
  
  '|> rendement(nom : "converti en ensemble de données d'apprentissage supervisé")'
  
  )
  
  df = df.drop(columns=['table', 'result'])
  
  data = df.to_numpy()
  
  
  
  # diviser un ensemble de données univariées en ensembles d'entraînement/test
  
  def train_test_split(data, n_test):
  
  return data[:-n_test:], data[-n_test:]
  
  
  
  # adapter un modèle xgboost et effectuer une étape prédiction
  
  def xgboost_forecast(train, testX):
  
  # transformer la liste en tableau
  
  train = asarray(train)
  
  # diviser en colonnes d'entrée et de sortie
  
  trainX, trainy = train[:, :-1], train[:, -1]
  
  # fit model
  
  model = XGBRegressor(objective='reg:squarederror', n_estimators=1000)
  
  model.fit(trainX, trainy)
  
  # faire une prédiction en une étape
  
  yhat = model.predict(asarray([testX]))
  
  return yhat[0]
  
  
  
  # walk-forward validation pour les données univariées
  
  def walk_forward_validation(data, n_test):
  
  prédictions = list()
  
  # ensemble de données divisé
  
  train, test = train_test_split(data, n_test)
  
  history = [x for x in train]
  
  # franchir chaque pas de temps dans l'ensemble de test
  
  pour i in range(len( test)):
  
  # diviser la ligne de test en colonnes d'entrée et de sortie
  
  testX, testy = test[i, :-1], test[i, -1]
  
  # ajuster le modèle sur l'historique et faire une prédiction
  
  yhat = xgboost_forecast(history, testX)
  
  # stocker les prévisions dans la liste des prédictions
  
  predictions.append(yhat)
  
  # ajouter l'observation réelle à l'historique pour la prochaine boucle
  
  history.append(test[i])
  
  # résumer les progrès
  
  print('>expected=%.1f, prédit=%.1f' % (testy, yhat))
  
  # estimer l'erreur de prédiction
  
  error = mean_absolute_error(test[:, -1], prédictions )
  
  erreur de retour, test[:, -1], prédictions
  
  
  
  #évaluer
  
  mae, y, yhat = walk_forward_validation(data, 100)
  
  print('MAE : %.3f' % mae)
  
  
  
  # intrigue attendue vs prédite
  
  pyplot.plot(y, label='Expected')
  
  pyplot.plot(yhat, label='Predicted')
  
  pyplot.legend()
  
  pyplot.show()

  五、结论

  希望这篇博文能够激励人们利用XGBoost et InfluxDB进行预测。为此建议查看相关Il s'agit d'un système d'information sur la base de données d'InfluxDB. 。

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

  

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!