Fichier	Description
coordinates_toulouse.csv	Contient les noms des stations de Toulouse ainsi que leurs coordonnées géographiques (latitude et longitude).
distance_toulouse.csv	Représente une matrice des distances (à vol d’oiseau) entre les différentes stations de vélos.
X_hour_toulouse.csv	Observations horaires de la proportion de vélos disponibles dans les différentes stations. Chaque ligne représente une observation horaire pendant environ six mois. Il y a une observation par heure pour chaque station.

Théorie derrière l'ACP

L’Analyse en Composantes Principales (ACP) est une technique statistique utilisée pour réduire la dimensionnalité d’un jeu de données tout en conservant le maximum d’information possible. Elle transforme les variables originales en un nouveau jeu de variables, appelées composantes principales, qui sont des combinaisons linéaires des variables originales.

Les étapes des l'ACP

Standardisation des données : Pour éviter que des variables à grande échelle dominent les autres, les données sont standardisées (centrées et réduites) : $z_{ij} = \frac{x_{ij} - \bar{x}_j}{s_j}$ où $ x_{ij} $ est la valeur de la $ i $-ème observation pour la $ j $-ème variable, $ \bar{x}_j $ est la moyenne de la $ j $-ème variable, et $ s_j $ est l’écart-type de la $ j $-ème variable.
Calcul de la matrice de covariance : La matrice de covariance $ \mathbf{C} $ est calculée à partir des données standardisées : $\mathbf{C} = \frac{1}{n-1} \mathbf{Z}^T \mathbf{Z}$ où $ \mathbf{Z} $ est la matrice des données standardisées.
Calcul des valeurs propres et des vecteurs propres : Les valeurs propres $ \lambda $ et les vecteurs propres $ \mathbf{v} $ de la matrice de covariance $ \mathbf{C} $ sont calculés pour obtenir les composantes principales : $\mathbf{C} \mathbf{v} = \lambda \mathbf{v}$
Sélection des composantes principales : Les vecteurs propres associés aux plus grandes valeurs propres sont sélectionnés comme composantes principales. Les valeurs propres représentent la quantité de variance expliquée par chaque composante principale.
Projection des données : Les données standardisées sont projetées sur les composantes principales pour obtenir les nouvelles coordonnées : $\mathbf{Y} = \mathbf{Z} \mathbf{V}$ où $ \mathbf{Y} $ est la matrice des données projetées et $ \mathbf{V} $ est la matrice des vecteurs propres.

L’ACP permet de réduire la dimensionnalité des données en conservant les composantes principales qui expliquent la majeure partie de la variance totale. Cette technique est largement utilisée en analyse de données, apprentissage automatique et visualisation de données.

Théorie derrière MAE et MSE

MAE

L’Erreur Moyenne Absolue (MAE) est une métrique d’évaluation qui mesure la différence moyenne absolue entre les valeurs réelles et les valeurs prédites. Elle est calculée en prenant la moyenne des valeurs absolues des erreurs individuelles. La formule pour le MAE est :

\[MAE = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y}_i|\]

où $y_i$ est la valeur réelle, $\hat{y}_i$ est la valeur prédite, et $n$ est le nombre total d’observations.

MSE

L’Erreur Quadratique Moyenne (MSE) est une métrique d’évaluation qui mesure la moyenne des carrés des erreurs. Elle pénalise plus sévèrement les grandes erreurs en élevant les différences au carré. La formule pour le MSE est :

\[MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2\]

où $y_i$ est la valeur réelle, $\hat{y}_i$ est la valeur prédite, et $n$ est le nombre total d’observations.

Code python de la classe ForecastModel

import pandas as pd
import joblib
from sklearn.metrics import mean_squared_error, mean_absolute_error
from typing import Self, Any
from data.city.load_cities import City
from data.data import get_interpolated_indices
from abc import ABC, abstractmethod

PATH_MODEL: str = './data/prediction/methods/'

class ForecastModel(ABC):
    name = 'BaseModel'
    
    def __init__(self: Self, city: City, train_size: float=0.7) -> None:
        self.city = city
        self.train_size = train_size

        self.df_dataset = city.df_hours.copy()
        self.df_dataset = self.df_dataset.set_index('date')
        
        self.split_data()

    def split_data(self: Self) -> None:
        split_point = int(len(self.city.df_hours) * self.train_size)
        self.train_dataset = self.df_dataset.iloc[:split_point]
        self.test_dataset = self.df_dataset.iloc[split_point:]
    
    def save_model(self: Self, model: Any, station_name: str, compress: int=3) -> None:
        joblib.dump(model, f'{PATH_MODEL}{self.name}/{station_name}.pkl', compress=compress)

    def load_model(self: Self, station_name: str) -> Any:
        return joblib.load(f'{PATH_MODEL}{self.name}/{station_name}.pkl')

    @abstractmethod
    def train(self: Self) -> None:
        pass

    @abstractmethod
    def predict(self: Self, selected_station: str, data: pd.Series, forecast_length: int) -> pd.Series: # DOIT RETOURNER UNE SERIE !
        pass
    
    @staticmethod
    def create_features_from_date(date_serie: pd.Series) -> pd.DataFrame:
        df_X = pd.DataFrame()
        df_X['hour'] = date_serie.dt.hour.astype('uint8')
        df_X['day_of_week'] = date_serie.dt.dayofweek.astype('uint8')
        df_X['day_of_month'] = date_serie.dt.day.astype('uint8')
        df_X['is_weekend'] = (date_serie.dt.dayofweek >= 5).astype('uint8')
        df_X['is_sunday'] = (date_serie.dt.dayofweek == 6).astype('uint8')
        return df_X

    @staticmethod
    def get_DatetimeIndex_forecasting(serie: pd.Series, prediction_length: int) -> pd.DatetimeIndex:
        return pd.date_range(serie.index[-1], periods=prediction_length, freq='1h', inclusive='left')
    
    @staticmethod
    def get_metrics(predicted: pd.Series, reality: pd.Series, metrics: str='all', exclude_interpolation_weights: bool=True) -> dict[str, float]:
        sample_weight = pd.Series(1, reality.index)
        if exclude_interpolation_weights:
            sample_weight[get_interpolated_indices(reality)] = 0

        metrics_dict: dict[str, float] = {}
        if metrics == 'all' or metrics == 'mse':
            metrics_dict['mse'] = mean_squared_error(reality, predicted, sample_weight=sample_weight)
        if metrics == 'all' or metrics == 'mae':
            metrics_dict['mae'] = mean_absolute_error(reality, predicted, sample_weight=sample_weight)
        return metrics_dict

Voici le modèle de base que nous avons utilisé pour implémenter nos différents modèles de prédiction. Il s’agit d’une classe abstraite ForecastModel qui définit les méthodes et les attributs communs à tous les modèles.

Code python du modèle XGBoost

import pandas as pd
from xgboost import XGBRegressor
from os import makedirs
from typing import Self

from data.city.load_cities import City
from data.data import get_interpolated_indices
from data.prediction.forecast_model import ForecastModel, PATH_MODEL

class XGBoost(ForecastModel):
    name = 'XGBoost'

    def __init__(self: Self, city: City, train_size: float = 0.7) -> None:
        super().__init__(city, train_size)
        makedirs(f'{PATH_MODEL}{self.name}', exist_ok=True)
        self.models = {}

    def train(self: Self) -> None:
        df = self.train_dataset.copy()

        for station in df.columns:
            try:
                current_model = self.load_model(station)
            except FileNotFoundError:
                # Exclure les indices interpolés pour la station
                interpolated_indices = get_interpolated_indices(df[station], output_type='mask')
                df_filtered = df.drop(index=interpolated_indices)

                df_X = ForecastModel.create_features_from_date(df_filtered.index.to_series())
                df_y = df_filtered[station]

                current_model = XGBRegressor(n_estimators=70, max_depth=9, learning_rate=0.08)
                current_model.fit(df_X, df_y)

                self.save_model(current_model, station)
            
            self.models[station] = current_model

    def predict(self: Self, selected_station: str, data: pd.Series, forecast_length: int) -> pd.Series:
        if selected_station not in self.models:
            raise ValueError(f'Model for station {selected_station} not found.')

        data_index = ForecastModel.get_DatetimeIndex_forecasting(data, forecast_length)
        df_X_future = ForecastModel.create_features_from_date(data_index.to_series())

        model = self.models[selected_station]
        predictions = model.predict(df_X_future)
        predictions = predictions.clip(0, 1)
        
        return pd.Series(predictions, index=data_index, name=self.name)

Voici l’implementation du modèle XGBoost qui hérite de la classe ForecastModel. Ce modèle utilise l’algorithme de boosting XGBoost pour améliorer la précision des prédictions. Il est entraîné sur les données historiques et utilisé pour prédire la disponibilité des vélos.

Recherche sur la Prédiction de Séries Temporelles sur des Réseaux de Capteurs pour les Stations de Vélos à Toulouse

Introduction

Présentation du Sujet

Contextualisation

Présentation des Données

Analyse Statistique des Données

Distribution des Stations de Vélos

Analyse des Corrélations

Prédiction des Activités des Stations de Vélo

Objectifs de Prédiction

Méthode d’Entraînement des Modèles

Métriques d’Évaluation

Description des Modèles de Prédiction

Implémentation des Modèles en Python

Résultats et Visualisations

Comparaison des Modèles

Performances Globales

Analyse Géographique des Métriques

Conclusion et Observations

Analyse Statistique des Données

Prédictions et Comparaison des Modèles

Réflexions et Perspectives d’Amélioration