Prédiction Dynamique de Puissance pour un Cycle Rankine-Hirn avec XGBoost : Une Approche Robuste

Prédire la puissance générée par un cycle Rankine-Hirn avec surchauffe, surtout avec des données à haute fréquence (chaque minute), représente un défi classique en prévision de séries temporelles. Vous avez déjà effectué un travail préparatoire essentiel (nettoyage, normalisation, analyse de corrélation, création de lags), mais les prédictions plates ou incohérentes obtenues avec XGBoost indiquent souvent des problèmes subtils dans la gestion des dépendances temporelles, la stratégie de prédiction multi-pas, ou la configuration du modèle.

Cet article propose une approche complète et structurée, accompagnée d'un code Python détaillé (style notebook Jupyter), pour aborder ce problème. Nous nous concentrerons sur une modélisation qui respecte scrupuleusement l'ordre chronologique, utilise une stratégie de *feature engineering* adaptée aux séries temporelles, et implémente une prédiction récursive pour l'horizon de 24 heures (1440 minutes), tout en fournissant les outils d'évaluation et de visualisation demandés.

Points Clés pour une Prédiction Réussie

• Feature Engineering Temporel : La création de variables retardées (lags) et de caractéristiques temporelles cycliques (heure, jour) est cruciale pour que XGBoost comprenne la dynamique et la saisonnalité du système.
• Prédiction Récursive : Pour prévoir sur 1440 pas, une stratégie récursive est courante mais propage les erreurs. Chaque prédiction est réinjectée comme donnée d'entrée pour l'étape suivante. Une gestion attentive est nécessaire.
• Validation Chronologique : La division des données et la validation doivent strictement respecter l'ordre temporel pour éviter les fuites d'informations du futur et obtenir une évaluation réaliste des performances.

Comprendre le Cycle Rankine-Hirn

Une base thermodynamique essentielle

Le cycle de Hirn est une amélioration du cycle de Rankine de base, largement utilisé dans les centrales thermiques pour produire de l'électricité. Sa caractéristique principale est l'ajout d'une étape de surchauffe de la vapeur après sa sortie de la chaudière et avant son entrée dans la turbine. Cette surchauffe augmente la température de la vapeur à pression constante, ce qui améliore le rendement thermodynamique global du cycle et réduit l'humidité en fin de détente dans la turbine, protégeant ainsi ses ailettes.

La puissance générée dépend de nombreux facteurs dynamiques : débits, pressions, températures à différentes étapes du cycle (pompe, chaudière, surchauffeur, turbine, condenseur), ainsi que des conditions externes ou opérationnelles. Modéliser ces interactions complexes à partir de données temporelles est précisément ce que XGBoost peut accomplir grâce à sa capacité à capturer les non-linéarités et les interactions entre variables.

Schéma illustrant le fonctionnement d'une centrale thermique basée sur un cycle vapeur, similaire au Rankine-Hirn.

Pipeline de Prédiction avec XGBoost

De la donnée brute à la prévision sur 24 heures

Nous allons suivre un pipeline structuré pour développer notre modèle de prévision. Ce pipeline couvre toutes les étapes demandées, de la préparation des données à l'évaluation finale.

1. Chargement et Préparation Initiale des Données

La première étape consiste à charger vos données (437 900 lignes x 25 colonnes), s'assurer que la colonne de date est au format datetime, trier les données chronologiquement et la définir comme index. Bien que vous ayez déjà nettoyé et normalisé, ces étapes de vérification sont fondamentales.

2. Ingénierie des Caractéristiques (Feature Engineering)

C'est une étape critique pour les modèles comme XGBoost qui ne gèrent pas nativement la séquentialité. Nous allons créer :

• Caractéristiques Temporelles : Heure du jour, jour de la semaine, jour de l'année, etc. Ces features aident le modèle à identifier des cycles journaliers, hebdomadaires ou annuels. Un encodage cyclique (sin/cos) est recommandé pour éviter les discontinuités (ex: heure 23 proche de heure 0).
• Variables Retardées (Lags) : Valeurs passées de la variable cible ('Puissance') et potentiellement des variables explicatives les plus importantes. Le nombre de lags (la taille de la "fenêtre") est un hyperparamètre important. Par exemple, inclure les valeurs des 60 dernières minutes.
• Statistiques Mobiles (Optionnel) : Moyennes ou écarts-types calculés sur des fenêtres temporelles glissantes (ex: moyenne de la puissance sur les 6 dernières heures).

Après la création des lags, les premières lignes contenant des NaN seront supprimées.

Centrale thermique où un cycle Rankine-Hirn pourrait être implémenté.

3. Division des Données (Train/Test)

Les données seront divisées en un ensemble d'entraînement et un ensemble de test en respectant l'ordre chronologique. Par exemple, les données jusqu'à une certaine date pour l'entraînement, et les données suivantes pour le test. Les 1440 dernières minutes de l'ensemble de test serviront de "vérité terrain" pour évaluer nos prédictions sur 24h.

4. Entraînement du Modèle XGBoost

Un modèle `XGBRegressor` sera entraîné sur l'ensemble d'entraînement. Nous utiliserons un sous-ensemble des données d'entraînement comme jeu de validation pour l'arrêt précoce (early stopping), ce qui permet d'éviter le surapprentissage et de déterminer un nombre optimal d'arbres (`n_estimators`). L'optimisation des hyperparamètres (via `GridSearchCV`, `RandomizedSearchCV` ou des outils comme Optuna) est fortement recommandée pour de meilleures performances, mais nous commencerons avec des valeurs raisonnables.

5. Prédiction Récursive sur 24 Heures (1440 Minutes)

C'est le cœur de la prévision multi-pas. La stratégie récursive fonctionne comme suit :

1. Utiliser les dernières données connues (features et lags) pour prédire la puissance à l'étape `t+1`.
2. Pour prédire l'étape `t+2`, mettre à jour les features : la prédiction de `t+1` devient le `lag_1` de la puissance, les anciens lags sont décalés (`lag_1` devient `lag_2`, etc.), et les features temporelles sont mises à jour pour l'instant `t+2`.
3. Répéter ce processus 1440 fois.

Cette méthode est simple à implémenter mais sensible à l'accumulation des erreurs : une erreur de prédiction à une étape se propage aux étapes suivantes.

6. Évaluation des Performances

Les prédictions obtenues pour les 1440 minutes seront comparées aux valeurs réelles observées (provenant de l'ensemble de test). Les métriques suivantes seront calculées :

• R² (Coefficient de Détermination) : Mesure la proportion de la variance de la variable cible expliquée par le modèle.
• MAE (Mean Absolute Error) : Erreur moyenne absolue, facile à interpréter dans l'unité de la puissance.
• MSE (Mean Squared Error) : Erreur quadratique moyenne, pénalise davantage les grosses erreurs.
• RMSE (Root Mean Squared Error) : Racine carrée du MSE, également dans l'unité de la puissance.

7. Analyse de l'Évolution des Erreurs

Pour comprendre comment la performance du modèle se dégrade (ou non) au fil de l'horizon de prévision, nous calculerons l'erreur (par exemple, la MAE) pour chaque heure des 24 heures prédites. Cela permet d'identifier si les erreurs augmentent significativement après quelques heures.

8. Visualisation

Des graphiques clairs sont essentiels :

• Un graphique comparant la série temporelle observée et la série prédite sur les 24 heures.
• Un graphique (ex: diagramme en bâtons) montrant l'évolution de l'erreur moyenne par heure.

Visualisation Synthétique du Workflow

Un aperçu du processus de prédiction

Le diagramme ci-dessous résume les étapes clés du pipeline que nous allons implémenter pour la prédiction de puissance avec XGBoost.

Code Python Complet (Style Jupyter Notebook)

Implémentation pas à pas

Voici le code Python qui met en œuvre le pipeline décrit. Assurez-vous d'avoir les bibliothèques nécessaires installées (`pandas`, `numpy`, `xgboost`, `scikit-learn`, `matplotlib`). Adaptez le chemin du fichier et les noms de colonnes à votre jeu de données.

# -*- coding: utf-8 -*-

# 1. Import des bibliothèques nécessaires
import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.model_selection import train_test_split # Bien que nous fassions un split manuel chrono
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import matplotlib.pyplot as plt
import warnings

# Ignorer les avertissements pour une meilleure lisibilité
warnings.filterwarnings('ignore')

# --- Configuration ---
Fichier_Donnees = 'votre_fichier_donnees.csv' # REMPLACEZ par le chemin réel
Colonne_Date = 'Date' # REMPLACEZ si nécessaire
Colonne_Cible = 'Power' # REMPLACEZ par le nom de votre colonne cible (puissance)
Colonnes_Explicatives = [f'Feature_{i}' for i in range(1, 24)] # Adaptez si noms différents
Horizon_Prediction_Minutes = 1440
Lag_Window_Size = 60 # Nombre de minutes passées à utiliser comme lag (à ajuster)

# --- 2. Chargement et Préparation Initiale ---
print("Chargement et préparation initiale des données...")
try:
    df = pd.read_csv(Fichier_Donnees)
    df[Colonne_Date] = pd.to_datetime(df[Colonne_Date])
    df = df.sort_values(Colonne_Date)
    df = df.set_index(Colonne_Date)

    # Sélectionner les colonnes pertinentes
    colonnes_a_garder = Colonnes_Explicatives + [Colonne_Cible]
    df = df[colonnes_a_garder]

    # Vérifier les valeurs manquantes (même si déjà nettoyé)
    if df.isnull().sum().sum() > 0:
        print("Attention : Des valeurs manquantes détectées. Application de ffill().")
        df = df.fillna(method='ffill') # Stratégie simple, adaptez si besoin

    print(f"Données chargées. Forme: {df.shape}")
    print(df.head())

except FileNotFoundError:
    print(f"Erreur: Fichier '{Fichier_Donnees}' non trouvé.")
    # Optionnel: Générer des données d'exemple pour tester le script
    print("Génération de données d'exemple...")
    dates = pd.date_range(start='2023-01-01 00:00', periods=437900, freq='T')
    data_example = {'Date': dates}
    data_example[Colonne_Cible] = (np.sin(np.linspace(0, 80*np.pi, len(dates))) * 100 +
                                   np.cos(np.linspace(0, 20*np.pi, len(dates))) * 50 +
                                   np.random.randn(len(dates)) * 20 +
                                   np.linspace(500, 800, len(dates)))
    for col in Colonnes_Explicatives:
        data_example[col] = np.random.rand(len(dates)) * 100
    df = pd.DataFrame(data_example)
    df[Colonne_Date] = pd.to_datetime(df[Colonne_Date])
    df = df.sort_values(Colonne_Date)
    df = df.set_index(Colonne_Date)
    df = df[colonnes_a_garder]
    print(f"Données d'exemple générées. Forme: {df.shape}")

except Exception as e:
    print(f"Une erreur est survenue lors du chargement: {e}")
    exit()

# --- 3. Ingénierie des Caractéristiques ---
print("\nCréation des caractéristiques temporelles et des lags...")
def create_features(data, target_col, lag_window):
    """
    Crée des features temporelles cycliques et des lags.
    """
    df_feat = data.copy()

    # Features temporelles
    df_feat['hour'] = df_feat.index.hour
    df_feat['dayofweek'] = df_feat.index.dayofweek
    df_feat['dayofyear'] = df_feat.index.dayofyear
    df_feat['month'] = df_feat.index.month
    # df_feat['year'] = df_feat.index.year # Peut être utile si plusieurs années

    # Encodage cyclique (recommandé)
    df_feat['hour_sin'] = np.sin(2 * np.pi * df_feat['hour'] / 24)
    df_feat['hour_cos'] = np.cos(2 * np.pi * df_feat['hour'] / 24)
    df_feat['dayofweek_sin'] = np.sin(2 * np.pi * df_feat['dayofweek'] / 7)
    df_feat['dayofweek_cos'] = np.cos(2 * np.pi * df_feat['dayofweek'] / 7)
    # Supprimer les features brutes après encodage
    df_feat = df_feat.drop(columns=['hour', 'dayofweek'])

    # Création des lags pour la variable cible
    print(f"Création de {lag_window} lags pour la cible '{target_col}'...")
    for i in range(1, lag_window + 1):
        df_feat[f'{target_col}_lag_{i}'] = df_feat[target_col].shift(i)

    # Optionnel: Créer des lags pour les features explicatives importantes
    # features_to_lag = ['Feature_1', 'Feature_5'] # Exemple
    # for feature in features_to_lag:
    #     print(f"Création de {lag_window} lags pour la feature '{feature}'...")
    #     for i in range(1, lag_window + 1):
    #         df_feat[f'{feature}_lag_{i}'] = df_feat[feature].shift(i)

    # Supprimer les lignes avec NaN résultant des lags
    initial_rows = df_feat.shape[0]
    df_feat = df_feat.dropna()
    rows_dropped = initial_rows - df_feat.shape[0]
    print(f"{rows_dropped} lignes supprimées à cause des NaNs des lags.")

    return df_feat

df_processed = create_features(df, Colonne_Cible, Lag_Window_Size)
print(f"Données après feature engineering. Forme: {df_processed.shape}")
print(df_processed.head())

# --- 4. Division des Données (Train/Test Chronologique) ---
print("\nDivision des données en ensembles d'entraînement et de test...")

# Le test set contiendra les données nécessaires pour *évaluer* la prédiction de 1440 min
# L'entraînement se fera sur tout ce qui précède le début de la période de prévision
# Nous devons garder suffisamment de données dans test pour avoir la vérité terrain
split_point = df_processed.index[-Horizon_Prediction_Minutes]

train_df = df_processed.loc[df_processed.index < split_point]
test_df = df_processed.loc[df_processed.index >= split_point]

# Vérifier qu'on a bien 1440 points dans le test set final pour l'évaluation
if len(test_df) < Horizon_Prediction_Minutes:
     print(f"Attention : Moins de {Horizon_Prediction_Minutes} points disponibles pour le test final après création des lags.")
     # Ajuster si nécessaire, mais pour l'évaluation on ne peut utiliser que ce qui est disponible
     actual_test_horizon = len(test_df)
     print(f"L'évaluation se fera sur les {actual_test_horizon} dernières minutes disponibles.")
else:
     actual_test_horizon = Horizon_Prediction_Minutes
     # S'assurer que test_df n'a que la taille de l'horizon pour l'évaluation
     test_df = test_df.iloc[:actual_test_horizon]


X_train = train_df.drop(Colonne_Cible, axis=1)
y_train = train_df[Colonne_Cible]
X_test = test_df.drop(Colonne_Cible, axis=1) # Features pour la période à prédire
y_test = test_df[Colonne_Cible]   # Valeurs réelles pour comparer aux prédictions

# S'assurer que les colonnes sont dans le même ordre
feature_names = X_train.columns.tolist()
X_test = X_test[feature_names]


print(f"Taille de l'ensemble d'entraînement: {len(X_train)} points")
print(f"Taille de l'ensemble de test (pour évaluation): {len(y_test)} points")


# --- 5. Entraînement du Modèle XGBoost ---
print("\nEntraînement du modèle XGBoost...")
model = xgb.XGBRegressor(
    objective='reg:squarederror',
    n_estimators=1000,          # Nombre max d'arbres, early stopping choisira le meilleur
    learning_rate=0.05,         # Taux d'apprentissage
    max_depth=7,                # Profondeur max des arbres
    subsample=0.7,              # Fraction d'échantillons par arbre
    colsample_bytree=0.7,       # Fraction de features par arbre
    random_state=42,
    n_jobs=-1,                  # Utiliser tous les CPU disponibles
    # Pour GPU (si configuré): tree_method='gpu_hist', gpu_id=0
)

# Créer un jeu de validation à partir de la fin du train set pour early stopping
# Utiliser une fraction (ex: 10%) ou un nombre fixe de points
validation_size = int(len(X_train) * 0.1)
X_train_eval, y_train_eval = X_train.iloc[-validation_size:], y_train.iloc[-validation_size:]
X_train_fit, y_train_fit = X_train.iloc[:-validation_size], y_train.iloc[:-validation_size]

eval_set = [(X_train_fit, y_train_fit), (X_train_eval, y_train_eval)]

model.fit(X_train_fit, y_train_fit,
          eval_set=eval_set,
          eval_metric='rmse', # Root Mean Squared Error
          early_stopping_rounds=50, # Arrêter si le RMSE sur validation ne s'améliore pas pendant 50 rounds
          verbose=50) # Afficher le progrès tous les 50 rounds

print(f"Entraînement terminé. Meilleure itération: {model.best_iteration}")


# --- 6. Prédiction Récursive sur l'Horizon ---
print(f"\nPrédiction récursive des {actual_test_horizon} prochaines minutes...")

# Préparer le DataFrame initial pour la boucle de prédiction
# Il doit contenir toutes les features (y compris les lags) de la dernière observation *avant* la période de test
last_observation_features = train_df.iloc[-1].drop(Colonne_Cible)

# Si vous avez des lags de features explicatives, il faut une stratégie pour les mettre à jour
# Ici, on suppose que les features explicatives futures sont connues (prises de X_test)
# C'est une simplification forte ! Dans un vrai scénario 'online', il faudrait prédire aussi ces features
# ou utiliser des prévisions externes (ex: météo).

predictions = []
current_features_df = pd.DataFrame([last_observation_features]) # Doit être un DataFrame pour predict()

# S'assurer que les colonnes sont alignées avec l'entraînement
current_features_df = current_features_df[feature_names]


for i in range(actual_test_horizon):
    # Prédiction pour l'étape t+i+1
    pred_t_plus_1 = model.predict(current_features_df)[0]
    predictions.append(pred_t_plus_1)

    # Préparer les features pour l'étape suivante (t+i+2)
    if i < actual_test_horizon - 1:
        # Créer une nouvelle ligne pour les features de l'étape suivante
        next_features_series = X_test.iloc[i+1].copy() # Utilise les features NON-LAG réelles de la période de test

        # Mise à jour des lags de la CIBLE
        # Le lag_1 devient la prédiction qu'on vient de faire
        next_features_series[f'{Colonne_Cible}_lag_1'] = pred_t_plus_1
        # Décaler les autres lags de la cible
        for lag in range(2, Lag_Window_Size + 1):
            lag_col_current = f'{Colonne_Cible}_lag_{lag}'
            lag_col_previous = f'{Colonne_Cible}_lag_{lag-1}'
            if lag_col_current in next_features_series.index: # S'assurer que la colonne existe
                 # Utiliser la valeur du lag précédent DANS LA LIGNE PRÉCÉDENTE (current_features_df)
                 next_features_series[lag_col_current] = current_features_df.iloc[0][lag_col_previous]

        # Mise à jour des lags des FEATURES EXPLICATIVES (si applicable et modélisées)
        # ... (logique similaire si vous avez inclus des lags de features explicatives) ...

        # Mettre à jour current_features_df pour la prochaine itération
        current_features_df = pd.DataFrame([next_features_series], columns=feature_names)


# Convertir la liste de prédictions en Series pandas avec l'index temporel du test set
predictions_series = pd.Series(predictions, index=y_test.index)
print("Prédiction récursive terminée.")


# --- 7. Évaluation du Modèle ---
print(f"\nÉvaluation des performances sur les {actual_test_horizon} minutes prédites:")
mae = mean_absolute_error(y_test, predictions_series)
mse = mean_squared_error(y_test, predictions_series)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, predictions_series)

print(f"MAE (Mean Absolute Error): {mae:.4f}")
print(f"MSE (Mean Squared Error): {mse:.4f}")
print(f"RMSE (Root Mean Squared Error): {rmse:.4f}")
print(f"R² (Coefficient de Détermination): {r2:.4f}")

# --- 8. Suivi de l'Évolution des Erreurs par Heure ---
print("\nAnalyse de l'évolution de l'erreur par heure...")
# Calculer l'erreur absolue par minute
errors_df = pd.DataFrame({
    'Observed': y_test,
    'Predicted': predictions_series,
    'AbsoluteError': np.abs(y_test - predictions_series)
})

# Regrouper par heure et calculer la MAE moyenne par heure
hourly_mae = errors_df['AbsoluteError'].resample('H').mean()

print("MAE moyenne par heure de prédiction:")
print(hourly_mae)


# --- 9. Visualisation ---
print("\nGénération des graphiques...")

# Graphique 1: Observé vs Prédit
plt.figure(figsize=(18, 7))
plt.plot(y_test.index, y_test, label='Observé (Valeurs Réelles)', color='blue', linewidth=1.5)
plt.plot(predictions_series.index, predictions_series, label=f'Prédit (XGBoost Récursif - {actual_test_horizon} min)', color='red', linestyle='--', linewidth=1.5)
plt.title(f'Prédiction de la Puissance ({Colonne_Cible}) - Horizon {actual_test_horizon} Minutes')
plt.xlabel('Temps')
plt.ylabel('Puissance')
plt.legend()
plt.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout()
plt.show()

# Graphique 2: Évolution de l'erreur MAE par heure
plt.figure(figsize=(18, 6))
hourly_mae.plot(kind='bar', color='darkorange', alpha=0.8)
plt.title(f'Évolution de l\'Erreur Absolue Moyenne (MAE) par Heure sur {actual_test_horizon // 60} Heures')
plt.xlabel('Heure de Prédiction (début)')
plt.ylabel('MAE Moyenne')
plt.grid(True, axis='y', linestyle=':', alpha=0.7)
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()


# --- 10. Discussion et Pistes d'Amélioration ---
print("\nAnalyse des résultats et pistes d'amélioration:")
print("- Examinez les graphiques : La prédiction suit-elle la dynamique réelle ou devient-elle plate ?")
print("- Le R² est-il satisfaisant ? Une valeur faible ou négative indique un mauvais ajustement.")
print("- La MAE/RMSE sont-elles acceptables pour votre application ?")
print("- Le graphique d'erreur horaire montre-t-il une augmentation rapide de l'erreur ? C'est typique de la prédiction récursive.")

print("\nPour améliorer (si prédictions plates/incohérentes) :")
print("  - <b>Feature Engineering :</b>")
print("    - Augmenter/diminuer la `Lag_Window_Size`. Tester des lags spécifiques (ex: 24h, 1 semaine).")
print("    - Ajouter des features d'interaction ou polynomiales.")
print("    - Ajouter des statistiques mobiles (moyennes, std dev sur différentes fenêtres).")
print("    - Inclure des lags des features explicatives clés si elles ont un impact retardé.")
print("    - Vérifier la stationnarité des séries et appliquer des différenciations si nécessaire.")
print("  - <b>Optimisation XGBoost :</b>")
print("    - Utiliser GridSearchCV ou RandomizedSearchCV (avec `TimeSeriesSplit`) ou Optuna pour trouver les meilleurs hyperparamètres (learning_rate, n_estimators, max_depth, etc.).")
print("    - Ajuster les paramètres de régularisation (gamma, alpha, lambda).")
print("  - <b>Stratégie de Prédiction :</b>")
print("    - <b>Direct Multi-Step:</b> Entraîner un modèle distinct pour chaque pas de temps ou un modèle multi-output qui prédit les 1440 valeurs en une fois (plus complexe avec XGBoost standard).")
print("    - <b>Modèles Alternatifs:</b> Envisager des modèles spécifiques aux séries temporelles (ARIMA, Prophet) ou des réseaux de neurones (LSTM, GRU, N-BEATS) qui peuvent mieux gérer les dépendances à long terme.")
print("    - <b>Modèles Hybrides:</b> Combiner XGBoost avec d'autres approches.")
print("  - <b>Gestion des Exogènes:</b> Si les features explicatives futures ne sont pas connues, il faut aussi les prédire, ce qui ajoute de la complexité.")

print("\nScript terminé.")

  

Facteurs Influant sur la Performance du Modèle

Une analyse comparative

La qualité de la prédiction dépend de plusieurs facteurs interdépendants. Le graphique radar ci-dessous illustre l'importance relative (sur une échelle subjective de 1 à 10, où 10 est le plus important/impactant) de différents aspects pour obtenir des prédictions précises et dynamiques, en comparant une approche de base à une approche avancée.

Ce radar souligne que pour passer d'une performance de base à une performance optimisée, il faut accorder une attention particulière à la qualité des données, à une ingénierie des caractéristiques poussée (lags pertinents, features temporelles, potentiellement statistiques mobiles), à l'optimisation fine des hyperparamètres de XGBoost, et au choix judicieux (ou à l'amélioration) de la stratégie de prédiction multi-pas.

Résumé des Paramètres et Métriques Clés

Configuration et évaluation en un coup d'œil

Le tableau suivant résume certains paramètres de configuration importants utilisés dans l'approche proposée et les métriques d'évaluation clés pour juger de la performance du modèle.

Ce tableau sert de référence rapide pour les éléments configurables et les indicateurs à surveiller lors de l'exécution et de l'optimisation de votre modèle de prévision.

Foire Aux Questions (FAQ)

Références

Ressources pour approfondir

• How to Use XGBoost for Time Series Forecasting - Machine Learning Mastery
• Time Series Forecasting with XGBoost : A Comprehensive Guide - Medium
• Time-Series-Forecasting-with-XGBoost - GitHub Repository (chentphd)
• XGBoost for Time Series Forecasting - Analytics Vidhya
• Cycle de Hirn - Wikipédia
• XGBoost Python API Documentation - XGBoost Docs

Recherches Recommandées

Explorez davantage

Comment optimiser les hyperparamètres XGBoost pour les séries temporelles avec Optuna ?

Quelles sont les différences entre les stratégies de prédiction multi-step directe et récursive ?

Comment utiliser les réseaux LSTM pour la prédiction de séries temporelles sur un long horizon ?

Quelles techniques de feature engineering avancées sont utiles pour les séries temporelles énergétiques ?

geeksforgeeks.org

Sliding Window Technique | GeeksforGeeks

numpy.org

numpy.lib.stride_tricks.sliding_window_view — NumPy v2.3.dev0 Manual

github.com

GitHub - 862337210/PyRankine: The General Simulator of Rankine Cycle to ...

tespy.readthedocs.io

Rankine Cycle - TESPy 0.8.0.dev0 documentation

machinesintheclouds.com

Sliding Window Technique in Python

stackoverflow.com

python - Rolling or sliding window iterator? - Stack Overflow

fr.wikipedia.org

Cycle de Hirn — Wikipédia

stackoverflow.com

Sliding window approach for DNN - python - Stack Overflow

verteego.com

Pourquoi XGBoost n'est pas suffisant pour l'extrapolation… - Verteego

reddit.com

[D] Comment xgboost fonctionne-t-il avec les séries temporelles

medium.com

Time series analysis. A model comparison using XGBoost… - Medium

tutorialspoint.com

Modeling the Rankine Cycle in Python - Tutorialspoint

medium.com

Implement a sliding window using python | by Dinesh Kumar K B | ...

365datascience.com

How to Use XGBoost and LGBM for Time Series Forecasting?

kaggle.com

The Sliding Window - Kaggle

github.com

GitHub - thermalogic/SimRankine: The Rankine Cycle Steady-state ...

xgboosting.com

XGBoost Power Transform Time Series Data

datacamp.com

Tutoriel sur la prévision des séries temporelles - DataCamp

medium.com

Mastering the Sliding Window Technique: A Comprehensive Guide

research.chalmers.se

[PDF] Thermodynamic Cycles for Low- and High-Temperature Waste Heat ...

researchgate.net

(PDF) WORKING FLUID SELECTION OF RANKINE-HIRN CYCLE ACCORDING TO THE HEAT SOURCE

stackoverflow.com

What is Sliding Window Algorithm? Examples? - Stack Overflow

hal.science

[PDF] Experimental and numerical study of transcritical Organic Rankine ...

medium.com

Problem Solving Pattern — Sliding Window | by Tusamma Sal Sabil

bito.ai

Mastering the Sliding Window Algorithm in Programming: - Bito AI

analyticsvidhya.com

Use XGBoost for Time-Series Forecasting - Analytics Vidhya

builtin.com

Sliding Window Algorithm Explained | Built In

blog.finxter.com

5 Best Ways to Model the Rankine Cycle in Python

wikiwand.com

Cycle de Hirn - Wikiwand

journals.ametsoc.org

Improving Vortex Position Accuracy with a New Multiscale Alignment ...

aaqr.org

Application of the XGBoost Machine Learning Method in PM2.5 ...

filip-wojcik.com

PDF

fr.linux-console.net

Modélisation du cycle de Rankine en Python - Linux-Console.net

github.com

GitHub - chentphd/Time-Series-Forecasting-with-XGBoost

reddit.com

XGBoost pour la prédiction de séries chronologiques

medium.com

Les algorithmes de Machine Learning pour la prévision des séries ...

github.com

GitHub - adamrehn/slidingwindow: Sliding Window library for image ...

pythonalchemist.com

Mastering the Sliding Window Technique in Python

kaggle.com

Time Series Forcasting Using XGBoost - Kaggle

optimization-online.org

[PDF] CasADi – A software framework for nonlinear optimization and ...

machinelearningmastery.com

How to Use XGBoost for Time Series Forecasting

cantera.org

Rankine cycle — Cantera 3.2.0a1 documentation

pyimagesearch.com

Sliding Windows for Object Detection with Python and OpenCV - ...

medium.com

Time Series Forecasting with XGBoost : A Comprehensive Guide - Medium

github.com

GitHub - thermalogic/PyRankine: The Hybrid Steady-state Simulator of ...

researchgate.net

Optimization of automotive Rankine cycle waste heat recovery under ...