Die Flighty-App kann jetzt Flugverspätungen vorhersagen: So können Sie dies auch mithilfe von maschinellem Lernen tun

Die Top-App zur Flugverfolgung, Flighty, nutzt maschinelles Lernen sowie Daten der Luftfahrtbehörden, um jetzt frühzeitige Warnsignale für Verspätungen zu liefern und den genauen Grund für Verspätungen zu ermitteln. Mit dieser neuesten Version kann die App nun die beiden häufigsten Ursachen für Verspätungen identifizieren – verspätete Flugzeuge und Probleme im Luftraum – und den Benutzern frühzeitige Warnungen vor Verspätungen geben, bevor die Fluggesellschaften dies tun. Die Idee hinter dem Update besteht darin, Ihnen zu helfen, fundiertere Entscheidungen über Ihre Reisepläne zu treffen, indem Sie Informationen erhalten, die Fluggesellschaften normalerweise nicht geben.

Beispielsweise könnte eine Fluggesellschaft Ihre Reise um eine halbe Stunde, dann um eine Stunde usw. verzögern. Flighty kann Sie im Voraus warnen, dass Ihr Flug wahrscheinlich mindestens fünf Stunden Verspätung hat, beispielsweise aufgrund eines offiziellen Zwischenstopps an Ihrem Flughafen oder aufgrund von Wetterproblemen. Möglicherweise möchten Sie Maßnahmen ergreifen, z. B. umbuchen oder etwas länger warten, bis Sie zum Flughafen aufbrechen.

Wir gehen detailliert auf die Mechanik hinter der neuen Funktion von Flighty ein und zeigen Ihnen, wie Sie diese leistungsstarke Funktion zu Ihrem Projekt hinzufügen: Vorhersage von Flugverspätungen mit LSTM.

Einführung in die Flugverspätungsvorhersage

Die Vorhersage von Flugverspätungen kann eine große Herausforderung sein, da es viele Faktoren gibt, die Verspätungen beeinflussen können. Diese hängen meist mit Wetter, Flugverkehr und technischen Problemen zusammen. Solche Vorhersagemodelle könnten Fluggesellschaften dabei helfen, ihren Betrieb zu optimieren, die Zufriedenheit der Passagiere zu verbessern und die Betriebskosten zu senken.

Wichtige Funktionen zur Vorhersage von Flugverspätungen

Um ein effektives Modell zur Vorhersage von Flugverspätungen zu erstellen, ist es wichtig, eine Vielzahl von Funktionen zu verwenden, die Verspätungen beeinflussen können. In diesem Artikel verwenden wir die folgenden Funktionen:

• FL_DATE : Das Datum des Fluges.
• DEP_DELAY : Die Abfahrtsverspätung in Minuten.
• ORIGIN_CITY_NAME : Die Stadt, von der der Flug abfliegt.
• DEST_CITY_NAME : Die Zielstadt.
• CRS_DEP_TIME : Die geplante Abfahrtszeit.
• DISTANCE : Die Flugentfernung in Meilen.

Datenaufbereitung

Die Datenvorbereitung ist einer der wichtigsten Schritte beim Erstellen eines maschinellen Lernmodells. Wir werden einige historische Daten zu Flügen verwenden und einige Vorverarbeitungsschritte durchführen: Behandlung fehlender Werte, Kodierung kategorialer Merkmale und Normalisierung der Daten.

 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) 

Sequenzerstellung für LSTM

Eine Art rekurrentes neuronales Netzwerk ist das Long Short-Term Memory oder LSTM-Netzwerk, das speziell dafür entwickelt wurde, langfristige Abhängigkeiten in Zeitreihendaten zu lernen. Zunächst muss mithilfe von LSTM eine Sequenz von Datenpunkten erstellt werden.

 # 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)

Train-Test-Aufteilung

Als Nächstes teilen wir die Sequenzen in Trainings- und Testsätze auf, um die Leistung des Modells zu bewerten.

 # 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)

Erstellen des LSTM-Modells

Anschließend definieren und trainieren wir ein LSTM-Modell. Das Modell umfasst zwei LSTM-Schichten mit Dropout-Schichten zur Vermeidung von Überanpassung und eine dichte Ausgabeschicht.

 # 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)) 

Vorhersagen treffen

Nachdem wir das Modell trainiert haben, können wir es verwenden, um Vorhersagen anhand der Testdaten zu treffen und die Ergebnisse zu visualisieren.

 # 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

Interpretation der Ergebnisse

Das obige Diagramm zeigt tatsächliche und vorhergesagte Verzögerungen. Wenn die beiden Linien nur sehr geringe Abweichungen aufweisen, kann das Modell Verzögerungen gut vorhersagen. Es besteht jedoch immer noch Verbesserungspotenzial für das Modell durch Feinabstimmung der Hyperparameter, Hinzufügen weiterer Funktionen oder Verwendung fortschrittlicherer Architekturen.

Herausforderungen und Überlegungen

Trotz der Vorteile gibt es mehrere Herausforderungen und Überlegungen:

• Datenqualität : Die Qualität und Vollständigkeit der Daten selbst haben großen Einfluss darauf, wie gut die Vorhersagen sein können.
• Merkmalsauswahl : Die Auswahl der richtigen Merkmale für den Aufbau eines effektiven Modells.
• Modellkomplexität : Je höher die Komplexität eines Modells, desto rechenintensiver und schwieriger ist es zu interpretieren.

Abschluss

Im Allgemeinen ist maschinelles Lernen bei der Vorhersage von Flugverspätungen ein sehr leistungsfähiges Werkzeug. Es kann dazu beitragen, die Effizienz der Fluglinien in ihrem Betrieb enorm zu steigern und den Passagieren ein besseres Reiseerlebnis zu bieten. Sehen Sie sich die in diesem Artikel gegebenen Beispiele an, um Ihr eigenes Modell zur Vorhersage von Flugverspätungen zu implementieren und ein Gefühl für die Leistungsfähigkeit des maschinellen Lernens in diesem Bereich zu bekommen.

Dies ist nur eine der neueren Funktionen von Flighty, die zeigt, was mit maschinellem Lernen zur Lösung realer Probleme möglich ist. Im Zuge des technologischen und datenwissenschaftlichen Fortschritts wird die Genauigkeit dieser Art von Modellen und die Art der Probleme, auf die sie angewendet werden können, immer weiter verbessert und so den Weg zu intelligenterem und effizienterem Fliegen ebnen.

Nächste Schritte

Wer sein Modell weiter verbessern möchte, sollte Folgendes bedenken:

• Hyperparameter-Tuning : Verwenden Sie die Rastersuche oder die Zufallssuche, um die optimalen Hyperparameter Ihres Modells zu finden.
• Feature Engineering : Erkunden Sie andere Features, die Einfluss auf Flugverspätungen haben, wie Wetterbedingungen, Flugverkehrsdaten und Flugzeugtyp.
• Erweiterte Architekturen : Entwerfen Sie Experimente mit tiefen Architekturen, bidirektionalen LSTMs oder GRUs mit Aufmerksamkeitsmechanismen, um komplexere Muster in diesen Daten zu erfassen.

Durch kontinuierliche Iteration und Verbesserung kann eine höhere Genauigkeit für zuverlässigere Vorhersagen und damit ein reibungsloseres und effizienteres Fliegen erreicht werden.