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 :    : La date du vol. FL_DATE    : Le retard de départ en minutes. DEP_DELAY    : La ville d'où part le vol. ORIGIN_CITY_NAME    : La ville de destination. DEST_CITY_NAME    : L'heure de départ prévue. CRS_DEP_TIME    : La distance du vol en miles. DISTANCE  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 :    : La qualité et l’exhaustivité des données elles-mêmes influencent fortement la qualité des prévisions. Qualité des données    : Le choix des fonctionnalités appropriées pour la construction d'un modèle efficace. Sélection des fonctionnalités    : Plus la complexité d'un modèle est élevée, plus il nécessite de calculs intensifs et est difficile à interpréter. Complexité du modèle  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 :    : utilisez la recherche de grille ou la recherche aléatoire pour vous concentrer sur les hyperparamètres optimaux de votre modèle. Réglage des hyperparamètres    : 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. Ingénierie des fonctionnalités    : 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. Architectures avancé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.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

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

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Vous voulez gagner un concours d’écriture HackerNoon ? Voici ce que recommandent les gagnants du concours #crypto-api

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Appuyez pour gagner : Telegram pourrait intégrer les 10 prochains milliards d'utilisateurs de crypto avant Solana

Comment améliorer votre flux de travail par 10 : 17 applications essentielles

Vous voulez gagner un concours d’écriture HackerNoon ? Voici ce que recommandent les gagnants du concours #crypto-api

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Appuyez pour gagner : Telegram pourrait intégrer les 10 prochains milliards d'utilisateurs de crypto avant Solana

Comment améliorer votre flux de travail par 10 : 17 applications essentielles

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps