L’application Flighty peut désormais prédire les retards de vol : voici comment vous pouvez également le faire grâce au machine learning

Flighty, l'application de suivi des vols la plus populaire, utilise l'apprentissage automatique ainsi que les données des autorités aéronautiques pour fournir des signaux d'alerte précoces en cas de retard et identifier la raison exacte des retards. Avec cette dernière version, l'application est désormais capable d'identifier les deux principales causes de retard (les avions en retard et les problèmes d'espace aérien), fournissant aux utilisateurs un avertissement préalable sur les retards avant que les compagnies aériennes ne le fassent. L'idée derrière cette mise à jour est de vous aider à prendre des décisions plus éclairées concernant vos projets de voyage en vous fournissant des informations que les compagnies aériennes ne fournissent généralement pas.

Par exemple, une compagnie aérienne peut retarder votre voyage d'une demi-heure, puis d'une heure, et ainsi de suite. Flighty peut vous avertir à l'avance que votre vol est susceptible d'être retardé d'au moins cinq heures en raison d'un arrêt officiel à l'aéroport ou de problèmes météorologiques. Vous pouvez prendre des mesures telles que modifier votre réservation ou attendre un peu plus longtemps pour vous rendre à l'aéroport.

Nous approfondirons les mécanismes derrière la nouvelle fonctionnalité de Flighty et vous guiderons dans l'ajout de cette fonctionnalité puissante à votre projet : prédire les retards de vol à l'aide de LSTM.

Introduction à la prévision des retards de vol

Prévoir les retards de vol peut s'avérer très difficile en raison du nombre de facteurs pouvant être à l'origine des retards, principalement liés à la météo, au trafic aérien et aux problèmes techniques. De tels modèles de prévision pourraient s'avérer importants pour aider les compagnies aériennes à optimiser leurs opérations, à améliorer la satisfaction des passagers et à réduire les coûts opérationnels.

Principales caractéristiques de la prévision des retards de vol

Pour créer un modèle de prévision des retards de vol efficace, il est essentiel d'utiliser diverses fonctionnalités qui peuvent influencer les retards. Dans cet article, nous utiliserons les fonctionnalités suivantes :

• FL_DATE : La date du vol.
• DEP_DELAY : Le retard de départ en minutes.
• ORIGIN_CITY_NAME : La ville d'où part le vol.
• DEST_CITY_NAME : La ville de destination.
• CRS_DEP_TIME : L'heure de départ prévue.
• DISTANCE : La distance du vol en miles.

Préparation des données

La préparation des données est l'une des étapes majeures du processus de création d'un modèle d'apprentissage automatique. Nous utiliserons des données historiques sur les vols et effectuerons quelques étapes de prétraitement : gestion des valeurs manquantes, codage des caractéristiques catégorielles et normalisation des données.

 import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dense, Dropout # Load the flight data flights_df = pd.read_csv('path_to_your_flight_data.csv') # Convert FL_DATE to datetime and set as index flights_df['FL_DATE'] = pd.to_datetime(flights_df['FL_DATE']) flights_df.set_index('FL_DATE', inplace=True) # Select relevant columns and drop rows with NaN values features = ['DEP_DELAY', 'ORIGIN_CITY_NAME', 'DEST_CITY_NAME', 'CRS_DEP_TIME', 'DISTANCE'] flights_df = flights_df[features].dropna() # Convert categorical features to dummy variables flights_df = pd.get_dummies(flights_df, columns=['ORIGIN_CITY_NAME', 'DEST_CITY_NAME']) # Normalize the data scaler = MinMaxScaler() scaled_data = scaler.fit_transform(flights_df) 

Création de séquences pour LSTM

Un type de réseau neuronal récurrent est le réseau à mémoire à long terme ou LSTM, qui est spécialement conçu pour apprendre les dépendances à long terme dans les données de séries chronologiques. Tout d'abord, il sera nécessaire de créer une séquence de points de données à l'aide de LSTM.

 # Create sequences def create_sequences(data, seq_length): sequences = [] for i in range(len(data) - seq_length): seq = data[i:i+seq_length] target = data[i+seq_length][0] # DEP_DELAY is the target sequences.append((seq, target)) return sequences seq_length = 30 sequences = create_sequences(scaled_data, seq_length)

Séparation des trains et des tests

Ensuite, nous divisons les séquences en ensembles d’entraînement et de test pour évaluer les performances du modèle.

 # Split into train and test sets train_size = int(len(sequences) * 0.8) train_sequences = sequences[:train_size] test_sequences = sequences[train_size:] # Prepare the input and output X_train, y_train = zip(*train_sequences) X_train, y_train = np.array(X_train), np.array(y_train) X_test, y_test = zip(*test_sequences) X_test, y_test = np.array(X_test), np.array(y_test)

Construction du modèle LSTM

Nous définissons et formons ensuite un modèle LSTM. Le modèle comprend deux couches LSTM avec des couches de décrochage pour éviter le surapprentissage et une couche de sortie dense.

 # Build the LSTM model model = Sequential() model.add(LSTM(50, return_sequences=True, input_shape=(seq_length, X_train.shape[2]))) model.add(Dropout(0.2)) model.add(LSTM(50)) model.add(Dropout(0.2)) model.add(Dense(1)) model.compile(optimizer='adam', loss='mean_squared_error') # Train the model model.fit(X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test)) 

Faire des prédictions

Après avoir formé le modèle, nous pouvons l’utiliser pour faire des prédictions sur les données de test et visualiser les résultats.

 # Make predictions predictions = model.predict(X_test) predictions = scaler.inverse_transform(np.concatenate((predictions, np.zeros((predictions.shape[0], scaled_data.shape[1] - 1))), axis=1))[:, 0] from sklearn.preprocessing import MinMaxScaler future_flight_data = { 'DEP_DELAY': 0, 'ORIGIN_CITY_NAME': 'San Francisco, CA', 'DEST_CITY_NAME': 'New York, NY', 'CRS_DEP_TIME': 1230, 'DISTANCE': 2904 } future_flight_df = pd.DataFrame([future_flight_data]) future_flight_df = pd.get_dummies(future_flight_df, columns=['ORIGIN_CITY_NAME', 'DEST_CITY_NAME']) scaler_columns = list(scaler.feature_names_in_) for col in scaler_columns: if col not in future_flight_df.columns: future_flight_df[col] = 0 future_flight_df = future_flight_df[scaler_columns] # Normalize the data using the fitted scaler scaled_future_flight = scaler.transform(future_flight_df) seq_length = 30 # Repeat the future flight data to create a sequence future_sequence = np.array([scaled_future_flight] * seq_length) future_sequence = future_sequence.reshape(1, seq_length, future_sequence.shape[2]) predicted_delay = model.predict(future_sequence) predicted_delay = scaler.inverse_transform( np.concatenate( (predicted_delay, np.zeros((predicted_delay.shape[0], scaled_future_flight.shape[1] - 1))), axis=1 ) )[:, 0] print(f"Predicted delay for the specific future flight: {predicted_delay[0]:.2f} minutes")

 Predicted delay for the specific future flight: 4.10 minutes

Interprétation des résultats

Le graphique ci-dessus montre les retards réels et prévus. Si les deux lignes présentent un écart très faible, le modèle fait un bon travail de prévision des retards. Cependant, il est toujours possible d'améliorer le modèle en ajustant les hyperparamètres, en ajoutant des fonctionnalités supplémentaires ou en utilisant des architectures plus avancées.

Défis et considérations

Malgré les avantages, il existe plusieurs défis et considérations :

• Qualité des données : La qualité et l’exhaustivité des données elles-mêmes influencent fortement la qualité des prévisions.
• Sélection des fonctionnalités : Le choix des fonctionnalités appropriées pour la construction d'un modèle efficace.
• Complexité du modèle : Plus la complexité d'un modèle est élevée, plus il nécessite de calculs intensifs et est difficile à interpréter.

Conclusion

En général, l'apprentissage automatique dans la prévision des retards de vol est un outil très puissant ; il peut aider les compagnies aériennes à gagner en efficacité dans leurs opérations et à offrir une meilleure expérience de voyage aux passagers. Parcourez les exemples donnés dans cet article pour mettre en œuvre votre propre modèle de prévision des retards de vol et découvrez la puissance de l'apprentissage automatique dans ce domaine.

Il s'agit là d'une des nouvelles fonctionnalités de Flighty, qui met en évidence les possibilités offertes par l'apprentissage automatique pour résoudre des problèmes concrets. Au fil des avancées technologiques et de la science des données, ce type de modèle continuera à s'améliorer en termes de précision et de types de problèmes auxquels il peut être appliqué, ouvrant la voie à des voyages aériens plus intelligents et plus efficaces.

Prochaines étapes

Pour ceux qui souhaitent améliorer davantage leur modèle, tenez compte des éléments suivants :

• Réglage des hyperparamètres : utilisez la recherche de grille ou la recherche aléatoire pour vous concentrer sur les hyperparamètres optimaux de votre modèle.
• Ingénierie des fonctionnalités : explorez d’autres fonctionnalités qui influencent les retards de vol, comme les conditions météorologiques, les données sur le trafic aérien et le type d’avion.
• Architectures avancées : Concevez des expériences avec des architectures profondes, des LSTM bidirectionnels ou des GRU avec des mécanismes d'attention, pour détecter des modèles plus complexes dans ces données.

Grâce à des itérations et des améliorations continues, une plus grande précision peut être obtenue pour des prévisions plus fiables, et donc des voyages aériens plus fluides et plus efficaces.