La aplicación Flighty ahora puede predecir retrasos en los vuelos: así es como puedes hacerlo tú también mediante aprendizaje automático

La aplicación de seguimiento de vuelos Flighty utiliza el aprendizaje automático y los datos de las autoridades de aviación para ofrecer señales de alerta temprana sobre retrasos y determinar el motivo exacto de los mismos. Con esta última versión, la aplicación ahora es capaz de identificar las dos principales causas de los retrasos (retrasos de los aviones y problemas con el espacio aéreo), lo que proporciona a los usuarios una advertencia anticipada sobre los retrasos antes de que las aerolíneas lo hagan. La idea detrás de la actualización es ayudarlo a tomar decisiones más informadas sobre sus planes de viaje al brindarle información que las aerolíneas normalmente no le brindan.

Por ejemplo, una aerolínea puede retrasar tu viaje media hora, luego una hora, y así sucesivamente. Flighty puede avisarte con antelación de que es probable que tu vuelo se retrase al menos cinco horas debido a algo como una escala oficial en el aeropuerto o problemas meteorológicos. Es posible que quieras tomar medidas como volver a reservar o esperar un poco más para ir al aeropuerto.

Profundizaremos en la mecánica detrás de la nueva característica de Flighty y lo guiaremos en el proceso de agregar esta poderosa característica a su proyecto: predecir retrasos en los vuelos usando LSTM.

Introducción a la predicción de retrasos en vuelos

La predicción de retrasos en los vuelos puede ser muy complicada debido a la cantidad de factores que pueden influir en las demoras, en su mayoría relacionados con el clima, el tráfico aéreo y los problemas técnicos. Estos modelos de predicción podrían ser importantes para ayudar a las aerolíneas a optimizar las operaciones, mejorar la satisfacción de los pasajeros y reducir los costos operativos.

Características clave de la predicción de retrasos en vuelos

Para crear un modelo eficaz de predicción de retrasos en los vuelos, es esencial utilizar una variedad de características que pueden influir en los retrasos. En este artículo, utilizaremos las siguientes características:

• FL_DATE : La fecha del vuelo.
• DEP_DELAY : El retraso de salida en minutos.
• ORIGIN_CITY_NAME : La ciudad desde donde sale el vuelo.
• DEST_CITY_NAME : La ciudad de destino.
• CRS_DEP_TIME : La hora de salida programada.
• DISTANCE : La distancia del vuelo en millas.

Preparación de datos

La preparación de datos es uno de los pasos principales en el proceso de creación de un modelo de aprendizaje automático. Utilizaremos algunos datos históricos sobre vuelos y realizaremos un par de pasos de preprocesamiento: manejo de valores faltantes, codificación de características categóricas y normalización de los datos.

 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) 

Creación de secuencias para LSTM

Un tipo de red neuronal recurrente es la red de memoria a corto plazo o LSTM, que está especialmente diseñada para aprender dependencias a largo plazo en datos de series temporales. Primero, será necesario crear una secuencia de puntos de datos utilizando 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)

División de prueba y tren

A continuación, dividimos las secuencias en conjuntos de entrenamiento y prueba para evaluar el rendimiento del modelo.

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

Construyendo el modelo LSTM

Luego definimos y entrenamos un modelo LSTM. El modelo incluye dos capas LSTM con capas de omisión para evitar el sobreajuste y una capa de salida densa.

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

Haciendo predicciones

Después de entrenar el modelo, podemos usarlo para hacer predicciones sobre los datos de prueba y visualizar los resultados.

 # 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

Interpretación de los resultados

El gráfico anterior muestra los retrasos reales y previstos. Si las dos líneas muestran una desviación mínima, entonces el modelo está haciendo un buen trabajo de predicción de los retrasos. Sin embargo, siempre hay margen para mejorar el modelo mediante el ajuste de los hiperparámetros, la incorporación de más funciones o el uso de arquitecturas más avanzadas.

Desafíos y consideraciones

A pesar de los beneficios, existen varios desafíos y consideraciones:

• Calidad de los datos : la calidad y la integridad de los datos en sí influyen en gran medida en la calidad de las predicciones.
• Selección de características : la elección de características correctas para la construcción de un modelo efectivo.
• Complejidad del modelo : cuanto mayor sea la complejidad de un modelo, más intensivo en términos computacionales y más difícil de interpretar será.

Conclusión

En general, el aprendizaje automático en la predicción de retrasos de vuelos es una herramienta muy poderosa; puede ayudar a que las aerolíneas obtengan una eficiencia gigantesca en sus operaciones y brindar una mejor experiencia de viaje a los pasajeros. Revise los ejemplos que se ofrecen en este artículo para implementar su propio modelo de predicción de retrasos de vuelos y familiarizarse con el poder del aprendizaje automático en este ámbito.

Esta es solo una de las características más nuevas de Flighty, que destaca lo que es posible con el aprendizaje automático para resolver problemas del mundo real. En el proceso de avance tecnológico y de la ciencia de datos, este tipo de modelo seguirá mejorando en su precisión y en los tipos de problemas a los que se puede aplicar, allanando el camino hacia viajes aéreos más inteligentes y eficientes.

Próximos pasos

Para aquellos interesados en mejorar aún más su modelo, consideren lo siguiente:

• Ajuste de hiperparámetros : utilice la búsqueda en cuadrícula o la búsqueda aleatoria para localizar los hiperparámetros óptimos de su modelo.
• Ingeniería de características : explore otras características que influyen en los retrasos de los vuelos, como las condiciones climáticas, los datos de tráfico aéreo y el tipo de aeronave.
• Arquitecturas avanzadas : Diseñar experimentos con arquitecturas profundas, LSTM bidireccionales o GRU con mecanismos de atención, para capturar patrones más complejos en estos datos.

A través de la iteración y la mejora continuas, se puede lograr una mayor precisión para realizar predicciones más confiables y, en consecuencia, viajes aéreos más fluidos y eficientes.