Prédire la Consommation Électrique : Votre Guide Complet pour la Régression Linéaire Multiple (MLR)

La prédiction de la consommation électrique est cruciale pour la gestion des réseaux et l'optimisation des ressources. La Régression Linéaire Multiple (MLR) est une technique statistique puissante qui permet de modéliser la relation entre une variable cible (la consommation électrique) et plusieurs variables prédictives (features). Ce guide vous accompagnera pas à pas dans l'application de la MLR pour des prévisions à court terme (24 heures) et à long terme (1 semaine), en utilisant vos données spécifiques.

Points Clés à Retenir

• Préparation Rigoureuse : Le succès de la MLR repose sur une préparation minutieuse des données, incluant la gestion des dates, la création de features temporelles pertinentes, l'intégration des lags et la vérification de la multicolinéarité.
• Approche Temporelle : Pour les séries temporelles, la division des données (entraînement/test) doit respecter l'ordre chronologique (`shuffle=False`) pour simuler des conditions réelles de prévision.
• Évaluation Multidimensionnelle : L'évaluation ne se limite pas à une seule métrique. Analyser R², MAE et MSE conjointement offre une vue complète de la performance et des types d'erreurs du modèle.

Étape 1 : Préparation et Exploration des Données

Fondations Solides pour des Prédictions Fiables

Avant de construire le modèle, il est impératif de préparer vos données. Vos données sont déjà normalisées, ce qui est une excellente base. Assurons-nous que les autres aspects sont couverts.

Importation des Bibliothèques Essentielles

Nous commencerons par importer les bibliothèques Python nécessaires pour la manipulation des données, la modélisation et la visualisation.

# Manipulation des données
import pandas as pd
import numpy as np

# Modélisation et Évaluation
from sklearn.model_selection import train_test_split, TimeSeriesSplit
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
from statsmodels.stats.outliers_influence import variance_inflation_factor # Pour vérifier la multicolinéarité

# Visualisation
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

# Gestion des dates
from datetime import timedelta
  

Chargement et Traitement Initial des Données

Chargez votre jeu de données. La colonne de date doit être convertie au format datetime pour en extraire des informations temporelles utiles (heure, jour de la semaine, mois, etc.), qui peuvent être des prédicteurs importants de la consommation électrique.

# Charger les données (remplacez 'votre_fichier.csv' par le chemin réel)
df = pd.read_csv('votre_fichier.csv')

# Convertir la colonne date en datetime et la définir comme index
df['date'] = pd.to_datetime(df['date'])
df = df.set_index('date')

# Optionnel : Extraire des features temporelles supplémentaires si nécessaire
# df['heure'] = df.index.hour
# df['jour_semaine'] = df.index.dayofweek
# df['mois'] = df.index.month
# Assurez-vous que ces nouvelles features sont incluses dans vos 23 features si elles sont pertinentes

# Afficher les premières lignes et informations
print(df.head())
print(df.info())
  

Intégration et Sélection des Lags

Vous avez indiqué que les lag features (valeurs passées de la cible) sont prêtes. C'est crucial pour capturer l'autocorrélation dans les séries temporelles. Le choix du nombre de lags est important.

Recommandation pour le Nombre de Lags :

• Commencez avec un nombre de lags qui capture les dépendances à court terme pertinentes. Pour des données horaires visant une prévision sur 24h, un nombre entre 5 et 24 lags est souvent un bon point de départ. 5 lags (comme suggéré par une des sources) capturent les influences très récentes, tandis que 24 lags capturent le cycle journalier complet.
• Pour la prévision hebdomadaire, vous pourriez envisager des lags plus longs (ex: 24*7 = 168 pour la semaine précédente) ou des lags spécifiques aux jours précédents (lag 24, lag 48, etc.).
• Proposition initiale : Utilisons 24 lags pour capturer le cycle journalier, mais n'hésitez pas à expérimenter avec moins (ex: 5, 12) ou plus, en évaluant l'impact sur les performances via validation croisée.

# Supposons que vos colonnes de lag s'appellent 'lag_1', 'lag_2', ..., 'lag_N'
# Définir le nombre de lags que vous avez préparés ou souhaitez utiliser
n_lags = 24 # Adaptez selon vos features préparées ou votre choix

# Lister vos 23 features de base + les features temporelles pertinentes
base_features = ['feature1', 'feature2', ..., 'feature23'] # Remplacez par les noms réels
lag_features = [f'lag_{i}' for i in range(1, n_lags + 1)] # Adaptez si vos noms diffèrent

# Combiner toutes les features
all_features = base_features + lag_features # Ajoutez les features temporelles si créées (heure, jour_semaine...)

# Définir X (features) et y (cible)
# Assurez-vous que 'cible' est le nom de votre colonne de puissance électrique
y = df['cible']
X = df[all_features]

# Gérer les NaNs introduits par les lags (si non déjà fait)
# La création de lags génère des NaNs au début du DataFrame
initial_nans = X.isnull().sum().max() # Trouve le nombre max de NaNs (correspond au lag max)
if initial_nans > 0:
    print(f"Suppression des {initial_nans} premières lignes à cause des NaNs des lags.")
    X = X.iloc[initial_nans:]
    y = y.iloc[initial_nans:]

print("Dimensions de X après gestion des NaNs:", X.shape)
print("Dimensions de y après gestion des NaNs:", y.shape)
  

Vérification de la Multicolinéarité

Avec 23 features et des lags, il est possible que certaines variables soient fortement corrélées entre elles (multicolinéarité). Cela peut rendre les coefficients du modèle MLR instables et difficiles à interpréter. Le VIF (Variance Inflation Factor) est un outil utile pour détecter ce problème.

• VIF = 1 : Pas de corrélation.
• 1 < VIF < 5 : Corrélation modérée.
• VIF >= 5 ou 10 : Corrélation élevée, potentiellement problématique. Envisagez de supprimer la feature avec le VIF le plus élevé et de recalculer, ou utilisez des techniques de régularisation (Ridge, Lasso).

# Calculer le VIF pour chaque feature
vif_data = pd.DataFrame()
vif_data['feature'] = X.columns
vif_data['VIF'] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]

print("\nFacteurs d'Inflation de la Variance (VIF):")
print(vif_data.sort_values('VIF', ascending=False))

# Optionnel : Filtrer les features avec VIF élevé si nécessaire
# threshold_vif = 10
# high_vif_features = vif_data[vif_data['VIF'] >= threshold_vif]['feature']
# if not high_vif_features.empty:
#     print(f"\nFeatures avec VIF >= {threshold_vif}:", high_vif_features.tolist())
#     # Vous pourriez choisir de retirer ces features:
#     # X = X.drop(columns=high_vif_features)
#     # print("Features après suppression des VIF élevés:", X.columns.tolist())
  

Division des Données (Entraînement / Test)

Pour les séries temporelles, il est crucial de diviser les données chronologiquement pour éviter que le modèle ne "voie" le futur pendant l'entraînement. Nous utiliserons les données les plus anciennes pour l'entraînement et les plus récentes pour le test.

# Définir la taille de l'ensemble de test (ex: 20% des données les plus récentes)
test_size_ratio = 0.2
split_index = int(len(X) * (1 - test_size_ratio))

X_train, X_test = X.iloc[:split_index], X.iloc[split_index:]
y_train, y_test = y.iloc[:split_index], y.iloc[split_index:]

print(f"\nTaille de l'ensemble d'entraînement: {len(X_train)} observations")
print(f"Taille de l'ensemble de test: {len(X_test)} observations")
print(f"Période d'entraînement: {X_train.index.min()} à {X_train.index.max()}")
print(f"Période de test: {X_test.index.min()} à {X_test.index.max()}")
  

Étape 2 : Application du Modèle MLR

Entraînement et Prédiction Initiale

Maintenant que les données sont prêtes, nous pouvons entraîner le modèle de Régression Linéaire Multiple.

# Créer une instance du modèle MLR
model = LinearRegression()

# Entraîner le modèle sur les données d'entraînement
print("\nEntraînement du modèle MLR...")
model.fit(X_train, y_train)
print("Modèle entraîné.")

# Faire des prédictions sur l'ensemble de test
y_pred_test = model.predict(X_test)

# Optionnel : Examiner les coefficients du modèle
# coefficients = pd.DataFrame(model.coef_, X.columns, columns=['Coefficient'])
# print("\nCoefficients du modèle:")
# print(coefficients.sort_values('Coefficient', ascending=False))
  

Étape 3 : Visualisation des Performances

Comparer les Prédictions aux Valeurs Réelles

Une visualisation graphique est essentielle pour comprendre comment le modèle se comporte sur l'ensemble de test.

# Créer le graphique
plt.figure(figsize=(15, 7))
plt.plot(y_test.index, y_test.values, label='Valeurs Réelles', color='blue', linewidth=1.5)
plt.plot(y_test.index, y_pred_test, label='Prédictions MLR', color='red', linestyle='--', linewidth=1.5)

# Améliorer la lisibilité des dates sur l'axe X
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
plt.gca().xaxis.set_major_locator(mdates.AutoDateLocator(minticks=5, maxticks=10))
plt.gcf().autofmt_xdate() # Rotation automatique des dates

# Ajouter les titres et légendes
plt.title('Comparaison Valeurs Réelles vs. Prédictions MLR sur l\'Ensemble de Test', fontsize=16)
plt.xlabel('Date et Heure', fontsize=12)
plt.ylabel('Puissance Électrique (Unité Normalisée/Réelle)', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout() # Ajuste le layout pour éviter les chevauchements
plt.show()
  

Cette courbe permet d'identifier visuellement les périodes où le modèle performe bien et celles où il peine (sous-estimation, sur-estimation, décalage temporel).

La prédiction précise de la production et de la consommation, comme celle issue de sources photovoltaïques, est un enjeu majeur.

Étape 4 : Évaluation Quantitative et Analyse de l'Évolution

Mesurer la Précision avec R², MAE et MSE

Calculons les métriques clés pour quantifier la performance du modèle sur l'ensemble de test.

• R² (Coefficient de Détermination) : Proportion de la variance de la variable cible expliquée par le modèle. Proche de 1 indique un bon ajustement.
• MAE (Mean Absolute Error) : Erreur moyenne absolue entre prédictions et valeurs réelles. Interprétable dans l'unité de la cible.
• MSE (Mean Squared Error) : Erreur quadratique moyenne. Pénalise davantage les grandes erreurs.

# Calcul des métriques sur l'ensemble de test
r2_test = r2_score(y_test, y_pred_test)
mae_test = mean_absolute_error(y_test, y_pred_test)
mse_test = mean_squared_error(y_test, y_pred_test)
rmse_test = np.sqrt(mse_test) # Root Mean Squared Error, souvent plus interprétable que MSE

print(f"\n--- Métriques sur l'Ensemble de Test ---")
print(f"Coefficient de Détermination (R²): {r2_test:.4f}")
print(f"Erreur Absolue Moyenne (MAE): {mae_test:.4f}")
print(f"Erreur Quadratique Moyenne (MSE): {mse_test:.4f}")
print(f"Racine de l'Erreur Quadratique Moyenne (RMSE): {rmse_test:.4f}")
  

Analyse de l'Évolution des Métriques (Simuler les "Époques")

La MLR standard ne s'entraîne pas par époques comme les réseaux neuronaux. Cependant, on peut analyser l'évolution de la performance en utilisant une validation croisée spécifique aux séries temporelles (TimeSeriesSplit). Cela entraîne et évalue le modèle sur des fenêtres de données croissantes, simulant l'arrivée de nouvelles données.

# Utiliser TimeSeriesSplit pour la validation croisée temporelle
n_splits = 5 # Nombre de découpes temporelles
tscv = TimeSeriesSplit(n_splits=n_splits)

print(f"\n--- Analyse de l'Évolution des Métriques (Validation Croisée Temporelle avec {n_splits} splits) ---")

fold = 1
r2_scores, mae_scores, mse_scores = [], [], []

# X et y doivent être les données complètes (avant train/test split) pour tscv
X_full = pd.concat([X_train, X_test])
y_full = pd.concat([y_train, y_test])

for train_index, val_index in tscv.split(X_full):
    # Séparer les données pour ce fold
    X_train_cv, X_val_cv = X_full.iloc[train_index], X_full.iloc[val_index]
    y_train_cv, y_val_cv = y_full.iloc[train_index], y_full.iloc[val_index]

    # Entraîner un modèle temporaire sur les données d'entraînement du fold
    model_cv = LinearRegression()
    model_cv.fit(X_train_cv, y_train_cv)

    # Prédire sur l'ensemble de validation du fold
    y_pred_cv = model_cv.predict(X_val_cv)

    # Calculer et stocker les métriques pour ce fold
    r2_fold = r2_score(y_val_cv, y_pred_cv)
    mae_fold = mean_absolute_error(y_val_cv, y_pred_cv)
    mse_fold = mean_squared_error(y_val_cv, y_pred_cv)

    r2_scores.append(r2_fold)
    mae_scores.append(mae_fold)
    mse_scores.append(mse_fold)

    print(f"Fold {fold}/{n_splits} - R²: {r2_fold:.4f}, MAE: {mae_fold:.4f}, MSE: {mse_fold:.4f}")
    fold += 1

# Afficher les moyennes des métriques sur les folds
print(f"\nMoyenne R² (CV): {np.mean(r2_scores):.4f}")
print(f"Moyenne MAE (CV): {np.mean(mae_scores):.4f}")
print(f"Moyenne MSE (CV): {np.mean(mse_scores):.4f}")

# Idéalement, on s'attend à voir R² ↑ (ou se stabiliser) et MAE/MSE ↓ (ou se stabiliser)
# à mesure que la taille des données d'entraînement augmente (au fil des folds).
# Des fluctuations importantes peuvent indiquer une instabilité ou des changements dans les données.
  

Étape 5 : Prédictions Futures (24h et 1 Semaine)

Projeter la Consommation Électrique

Utilisons le modèle entraîné sur l'ensemble des données d'entraînement (`model`) pour prédire les prochaines 24 heures et la semaine suivante. Cela nécessite une approche itérative ou récursive, où les prédictions passées sont utilisées pour générer les lags nécessaires aux prédictions futures.

Fonction de Prédiction Récursive

Cette fonction prend le dernier vecteur de features connu et prédit pas à pas les valeurs futures.

def predict_future_recursive(model, last_known_features_df, steps, base_feature_names, lag_feature_names, future_exog_features=None):
    """
    Prédit récursivement les 'steps' prochaines valeurs.

    Args:
        model: Le modèle MLR entraîné.
        last_known_features_df (pd.DataFrame): Le dernier DataFrame de features connu (1 ligne).
        steps (int): Le nombre de pas de temps à prédire (ex: 24 pour 24h).
        base_feature_names (list): Noms des features non-lag (ex: météo, jour...).
        lag_feature_names (list): Noms des features de lag (ex: 'lag_1', 'lag_2'...).
        future_exog_features (pd.DataFrame, optional): DataFrame contenant les valeurs futures des features exogènes
                                                     (météo, heure, jour...) pour les 'steps' périodes.
                                                     Doit avoir 'steps' lignes et les colonnes de base_feature_names.

    Returns:
        np.array: Tableau des prédictions pour les 'steps' prochaines périodes.
    """
    predictions = []
    current_features = last_known_features_df.iloc[0].copy() # Copie de la dernière ligne de features
    n_lags = len(lag_feature_names)

    if future_exog_features is not None and len(future_exog_features) != steps:
        raise ValueError("future_exog_features doit avoir 'steps' lignes.")

    for i in range(steps):
        # Préparer le vecteur de features pour la prédiction actuelle
        # Utiliser les features exogènes futures si fournies
        if future_exog_features is not None:
            for feat in base_feature_names:
                 if feat in future_exog_features.columns:
                    current_features[feat] = future_exog_features.iloc[i][feat]

        features_for_pred = current_features[model.feature_names_in_].values.reshape(1, -1)

        # Faire la prédiction pour le pas suivant
        pred = model.predict(features_for_pred)[0]
        predictions.append(pred)

        # Mettre à jour les lags pour la prochaine itération
        # Décaler les lags existants
        for j in range(n_lags, 1, -1):
            current_features[f'lag_{j}'] = current_features[f'lag_{j-1}']
        # Insérer la nouvelle prédiction comme lag_1
        current_features['lag_1'] = pred

    return np.array(predictions)

# Préparation des données pour la prédiction future
# Utiliser la dernière ligne de l'ensemble de test comme point de départ
last_known_features_df = X_test.iloc[[-1]]
last_known_timestamp = X_test.index[-1]

# !!! IMPORTANT !!!
# Pour une prédiction réelle, vous aurez besoin des valeurs futures des features exogènes
# (météo prévue, heure future, jour futur, etc.).
# Ici, pour l'exemple, nous allons supposer qu'elles sont constantes ou générer des valeurs fictives.
# Dans une application réelle, il faut les obtenir (ex: prévisions météo).

# Exemple fictif de features exogènes futures (À REMPLACER PAR VOS VRAIES DONNÉES FUTURES)
future_dates_24h = pd.date_range(start=last_known_timestamp + timedelta(hours=1), periods=24, freq=df.index.freq)
future_exog_24h = pd.DataFrame(index=future_dates_24h)
# Remplissez future_exog_24h avec les valeurs prévues pour vos 'base_features'

future_dates_1w = pd.date_range(start=last_known_timestamp + timedelta(hours=1), periods=24*7, freq=df.index.freq)
future_exog_1w = pd.DataFrame(index=future_dates_1w)
# Remplissez future_exog_1w avec les valeurs prévues pour vos 'base_features'

# Pour cet exemple, nous allons réutiliser les dernières valeurs connues (CE N'EST PAS IDÉAL)
for feat in base_features:
    if feat in last_known_features_df.columns:
       future_exog_24h[feat] = last_known_features_df[feat].iloc[0]
       future_exog_1w[feat] = last_known_features_df[feat].iloc[0]
    # Mieux : Extraire heure, jour, etc. des dates futures si besoin
    # if feat == 'heure': future_exog_24h['heure'] = future_dates_24h.hour ...


# Prédiction des 24 prochaines heures
print("\nPrédiction des 24 prochaines heures...")
predictions_24h = predict_future_recursive(model, last_known_features_df, 24, base_features, lag_features, future_exog_24h)
df_pred_24h = pd.DataFrame({'Prediction': predictions_24h}, index=future_dates_24h)
print(df_pred_24h.head())


# Prédiction de la semaine prochaine (168 heures)
print("\nPrédiction de la semaine prochaine...")
predictions_1w = predict_future_recursive(model, last_known_features_df, 24*7, base_features, lag_features, future_exog_1w)
df_pred_1w = pd.DataFrame({'Prediction': predictions_1w}, index=future_dates_1w)
print(df_pred_1w.head())


# Visualisation des prédictions futures
plt.figure(figsize=(15, 7))
# Afficher une partie des données historiques pour le contexte
plt.plot(y_test.index[-100:], y_test.values[-100:], label='Historique Réel (Test Set)', color='blue')
# Afficher les prédictions
plt.plot(df_pred_24h.index, df_pred_24h['Prediction'], label='Prédiction 24h', color='orange', linestyle='--')
plt.plot(df_pred_1w.index, df_pred_1w['Prediction'], label='Prédiction 1 Semaine', color='green', linestyle=':')

plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
plt.gcf().autofmt_xdate()
plt.title('Prédictions Futures de la Consommation Électrique', fontsize=16)
plt.xlabel('Date et Heure', fontsize=12)
plt.ylabel('Puissance Électrique Prédite', fontsize=12)
plt.legend(fontsize=10)
plt.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout()
plt.show()

  

Recalcul des Erreurs pour les Prédictions Futures

Pour recalculer les erreurs R², MAE et MSE pour ces prédictions futures, vous devez attendre d'obtenir les valeurs réelles correspondantes. Une fois que vous avez les données réelles (`y_real_24h` et `y_real_1w`), le calcul est similaire à celui effectué sur l'ensemble de test.

# --- Une fois les données réelles disponibles ---
# Supposons que vous ayez chargé les vraies valeurs dans y_real_24h et y_real_1w
# y_real_24h = ... # Series pandas avec les vraies valeurs pour les 24h prédites
# y_real_1w = ...  # Series pandas avec les vraies valeurs pour la semaine prédite

# Assurez-vous que les index correspondent
# y_real_24h = y_real_24h.loc[df_pred_24h.index]
# y_real_1w = y_real_1w.loc[df_pred_1w.index]

# Calcul des erreurs pour les 24h
# if 'y_real_24h' in locals() and len(y_real_24h) == len(predictions_24h):
#     r2_24h = r2_score(y_real_24h, predictions_24h)
#     mae_24h = mean_absolute_error(y_real_24h, predictions_24h)
#     mse_24h = mean_squared_error(y_real_24h, predictions_24h)
#     rmse_24h = np.sqrt(mse_24h)
#     print(f"\n--- Métriques pour la Prédiction 24h (après observation) ---")
#     print(f"R²: {r2_24h:.4f}, MAE: {mae_24h:.4f}, MSE: {mse_24h:.4f}, RMSE: {rmse_24h:.4f}")
# else:
#     print("\nLes données réelles pour les 24h ne sont pas disponibles pour calculer les erreurs.")


# Calcul des erreurs pour la semaine
# if 'y_real_1w' in locals() and len(y_real_1w) == len(predictions_1w):
#     r2_1w = r2_score(y_real_1w, predictions_1w)
#     mae_1w = mean_absolute_error(y_real_1w, predictions_1w)
#     mse_1w = mean_squared_error(y_real_1w, predictions_1w)
#     rmse_1w = np.sqrt(mse_1w)
#     print(f"\n--- Métriques pour la Prédiction 1 Semaine (après observation) ---")
#     print(f"R²: {r2_1w:.4f}, MAE: {mae_1w:.4f}, MSE: {mse_1w:.4f}, RMSE: {rmse_1w:.4f}")
# else:
#     print("\nLes données réelles pour la semaine ne sont pas disponibles pour calculer les erreurs.")

# Note : Les performances se dégradent généralement avec l'horizon de prévision.
# Attendez-vous à des erreurs plus élevées pour la prédiction sur 1 semaine que sur 24h.
  

Visualisation Synthétique des Performances

Comparaison des Métriques Clés

Le graphique radar suivant offre une vue comparative des métriques de performance (normalisées pour la visualisation) obtenues sur l'ensemble de test et potentiellement pour les prévisions futures (si les valeurs réelles étaient disponibles). Ici, nous simulons des valeurs pour illustrer comment un tel graphique pourrait être interprété. Des valeurs plus proches du bord extérieur sont généralement meilleures pour R², tandis que des valeurs plus proches du centre sont meilleures pour MAE et MSE/RMSE.

Flux de Travail : Schéma Mental

Visualisation du Processus MLR

Ce schéma mental résume les étapes clés du processus d'application de la Régression Linéaire Multiple pour la prédiction de la consommation électrique, depuis la préparation initiale des données jusqu'à la prédiction future.

Problèmes Potentiels et Solutions

Anticiper et Résoudre les Défis Courants

Même avec une préparation soignée, certains défis peuvent survenir lors de l'application de la MLR aux séries temporelles.

Vidéo Explicative sur les Métriques

Comprendre MAE et MSE

Cette vidéo (en français) fournit des explications détaillées sur l'origine et l'interprétation des métriques couramment utilisées en régression, telles que l'Erreur Absolue Moyenne (MAE) et l'Erreur Quadratique Moyenne (MSE), que nous avons calculées pour évaluer notre modèle MLR.

Questions Fréquemment Posées (FAQ)

Références

Ces ressources fournissent des informations complémentaires sur les concepts abordés :

• Analyse des séries temporelles : étapes, types et exemples - MathWorks
• Time Series Forecast Error Metrics You Should Know - Towards Data Science
• Multiple Linear Regression (MLR) Forecast Error - NumXL Support
• Smart Electricity Meter Load Prediction in Dubai Using MLR, ANN ... - MDPI
• Quelles métriques pour mesurer la performance de vos prédictions de séries temporelles ? - Wadaef
• Régression linéaire multiple (MLR) - Commerce 2024 - Financed Journal

Recherches Recommandées

Pour approfondir votre compréhension et explorer des approches alternatives :

Comment améliorer les prédictions MLR avec des features d'interaction pour la consommation électrique ?

Comparaison entre MLR et modèles ARIMA pour la prévision de séries temporelles énergétiques.

Application de la régularisation Ridge ou Lasso à la MLR pour gérer la multicolinéarité dans les données de puissance.

Stratégies de prédiction multi-étapes (directe vs récursive) pour les séries temporelles.

e2m.fr

Métrologie prédictive du domaine électrique | E2M

essicolo.github.io

12 Les séries temporelles | Analyse et modélisation d’agro...

particulier.edf.fr

Calculer sa Puissance Électrique à la Maison - EDF Particulier

mdpi.com

Smart Electricity Meter Load Prediction in Dubai Using MLR, ANN ...

fr.financedjournal.com

Régression linéaire multiple (MLR) - Commerce 2024

repositorio.ufsc.br

[PDF] Caractérisation du câblage des réseaux industriels de puissance en ...

researchgate.net

(PDF) Machine Learning au service de la prédiction de la demande d ...

patents.google.com

WO2003012435A1 - Methode de determination d'au moins une ...

particuliers.engie.fr

Choisir la bonne puissance de compteur électrique pour équiper ...

iris.uniroma1.it

[PDF] Advancing knowledge on speed management and developing ... - IRIS

pompe-moteur.fr

Comment calculer la puissance d'un moteur électrique ? - Pompe&Moteur

reddit.com

[Q] Prévision avec régression linéaire multiple : r/statistics - Reddit

services-rte.com

Consumption forecast - RTE Services Portal

culturesciencesphysique.ens-lyon.fr

Machine learning appliqué au domaine de l’énergie

ensai.fr

PDF

resources.altium.com

La MLI dans la conception d'alimentation électrique

revues.imist.ma

Machine Learning au service de la prédiction de la demande d’énergie ...

github.com

How to use mlr for time series regression · Issue #309 - GitHub

researchgate.net

Notice of Violation of IEEE Publication Principles: Short-term load ...

rpubs.com

RPubs - Prédiction de la probabilité d'avoir une maladie cardiaque.

dexma.com

Prévision de Consommation d'Énergie grâce au Machine Learning

christophenicault.com

Compétition de prévisions de ventes : M5 Forecasting Accuracy

nehoov.com

Use case : Prévision de la consommation électrique ...

theses.hal.science

[PDF] Analysis and control of the stability of power systems with a high ...

didierdelignieresblog.wordpress.com

PDF

santepubliquefrance.fr

Séries temporelles et modèles de régression

ftp.thepearlsf.com

[PDF] Parking Brake Ford Explorer

support.numxl.com

Multiple Linear Regression (MLR) Forecast Error - Help center

theses.fr

Prévision à court terme et gestion des consommations d'énergie ...

medium.com

Time Series Forecast Error Metrics you should know - Medium

docs.aws.amazon.com

Étape 4 : Évaluer les prédicteurs - Principes de prévisions ...

math.univ-lille1.fr

Cours de Séries Temporelles

fr.mathworks.com

Analyse des séries temporelles : étapes, types et exemples

repository.univ-msila.dz

Modèles de machine Learning pour la prédiction de la consommation en ...

edf-solutions-solaires.com

Quelle est la puissance électrique de votre maison ?

quantmetry.com

Détection d'anomalies dans les séries temporelles - Quantmetry

cloud.google.com

What is Time Series | Google Cloud

www-rocq.inria.fr

PDF

coursprof.com

Cours Évaluation de modèles statistiques PDF - Statistiques et ...

blog.statoscop.fr

Les séries temporelles avec Python (4/4) - Analyse et modélisation

fr.wadaef.net

Quelles métriques pour mesurer la performance de vos prédictions de ...

theses.hal.science

[PDF] Recherche de séries temporelles à l'aide de DTW-preserving ...

discovery.researcher.life

Published Scholarly Research Articles from office national de l ...

mathworks.com

Modèles de régression de séries temporelles

escholarship.org

Short-term Electric Load Prediction using Multiple Linear ...

imo.universite-paris-saclay.fr

Projet Machine Learning pour la Prévision: séries temporelles

totalenergies.fr

Comment choisir la puissance d’un compteur électrique ?

online.stat.psu.edu

Lesson 7: MLR Estimation, Prediction & Model Assumptions

researchgate.net

Analyse, classification et prédiction de consommation d’eau et d ...