O aplicativo Flighty agora pode prever atrasos de voos: veja como você também pode fazer isso usando aprendizado de máquina

O melhor aplicativo de rastreamento de voos, Flighty, está usando aprendizado de máquina, bem como dados das autoridades de aviação para agora servir sinais de alerta antecipados de atrasos e identificar uma razão exata por trás dos atrasos. Com este último lançamento, o aplicativo agora é capaz de identificar as duas maiores causas de atraso — aeronaves atrasadas e problemas de espaço aéreo — fornecendo aos usuários um aviso antecipado sobre atrasos antes que as companhias aéreas o façam. A ideia por trás da atualização é ajudar você a tomar decisões mais informadas sobre seus planos de viagem, fornecendo informações que as companhias aéreas normalmente não fornecem.

Por exemplo, uma companhia aérea pode atrasar sua viagem em meia hora, depois uma hora, e assim por diante. O Flighty pode alertá-lo com antecedência de que seu voo provavelmente atrasará por pelo menos cinco horas devido a algo como uma parada oficial no aeroporto ou problemas climáticos. Você pode querer tomar medidas como remarcar ou esperar um pouco mais para ir ao aeroporto.

Analisaremos detalhadamente a mecânica por trás do novo recurso do Flighty e mostraremos como adicionar esse recurso poderoso ao seu projeto: prever atrasos de voos usando LSTM.

Introdução à previsão de atraso de voo

A previsão de atrasos de voos pode ser muito desafiadora devido ao número de fatores que podem acabar sendo uma causa influenciadora de atrasos, principalmente relacionados ao clima, tráfego aéreo e problemas técnicos. Esses modelos de previsão podem ser importantes para ajudar as companhias aéreas a otimizar as operações, melhorar a satisfação dos passageiros e reduzir os custos operacionais.

Principais recursos na previsão de atraso de voo

Para construir um modelo de previsão de atraso de voo eficaz, é essencial usar uma variedade de recursos que podem influenciar atrasos. Neste artigo, usaremos os seguintes recursos:

• FL_DATE : A data do voo.
• DEP_DELAY : O atraso de partida em minutos.
• ORIGIN_CITY_NAME : A cidade de onde o voo parte.
• DEST_CITY_NAME : A cidade de destino.
• CRS_DEP_TIME : O horário de partida programado.
• DISTANCE : A distância do voo em milhas.

Preparação de dados

A Preparação de Dados é uma das principais etapas no processo de construção de um modelo de machine learning. Usaremos alguns dados históricos sobre voos e executaremos algumas etapas de pré-processamento: manipulando valores ausentes, codificando recursos categóricos e normalizando os dados.

 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) 

Criação de sequência para LSTM

Um tipo de rede neural recorrente é a rede de memória de longo prazo ou LSTM, que é especialmente projetada para aprender dependências de longo prazo em dados de séries temporais. Primeiro, será necessário criar uma sequência de pontos de dados usando 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)

Divisão de teste de trem

Em seguida, dividimos as sequências em conjuntos de treinamento e teste para avaliar o desempenho do 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)

Construindo o modelo LSTM

Em seguida, definimos e treinamos um modelo LSTM. O modelo inclui duas camadas LSTM com camadas de dropout para evitar overfitting e uma camada de saída 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)) 

Fazendo previsões

Depois de treinar o modelo, podemos usá-lo para fazer previsões sobre os dados de teste e visualizar os 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

Interpretando os resultados

O gráfico acima mostra atrasos reais e previstos. Se as duas linhas mostrarem muito pouco desvio, então o modelo está fazendo um bom trabalho de previsão de atrasos. No entanto, sempre há espaço para melhorias no modelo por meio do ajuste fino de hiperparâmetros ou da adição de mais recursos ou do uso de arquiteturas mais avançadas.

Desafios e Considerações

Apesar dos benefícios, existem vários desafios e considerações:

• Qualidade dos dados : a qualidade e a integridade dos dados em si influenciam muito a qualidade das previsões.
• Seleção de recursos : a escolha dos recursos corretos para a construção de um modelo eficaz.
• Complexidade do modelo : quanto maior a complexidade de um modelo, mais intensivo em termos computacionais e difícil de interpretar ele se torna.

Conclusão

Em geral, o aprendizado de máquina na previsão de atraso de voo é uma ferramenta muito poderosa; ele pode ajudar a trazer eficiência gigantesca para as companhias aéreas em suas operações e fornecer uma melhor experiência de viagem aos passageiros. Passe pelos exemplos dados neste artigo para implementar seu próprio modelo de um preditor de atraso de voo e tenha uma ideia do poder do aprendizado de máquina trabalhando neste domínio.

Este é apenas um dos recursos mais recentes do Flighty, destacando o que é possível com o aprendizado de máquina para resolver problemas do mundo real. No processo de avanço tecnológico e da ciência de dados, esse tipo de modelo continuará melhorando em sua precisão e nos tipos de problemas aos quais pode ser aplicado, abrindo caminho para viagens aéreas mais inteligentes e eficientes.

Próximos passos

Para aqueles interessados em aprimorar ainda mais seu modelo, considere o seguinte:

• Ajuste de hiperparâmetros : use a pesquisa em grade ou a pesquisa aleatória para identificar os hiperparâmetros ideais do seu modelo.
• Engenharia de recursos : explore outros recursos que influenciam atrasos de voos, como condições climáticas, dados de tráfego aéreo e tipo de aeronave.
• Arquiteturas avançadas : crie experimentos com arquiteturas profundas, LSTMs bidirecionais ou GRUs com mecanismos de atenção para capturar padrões mais complexos nesses dados.

Por meio de iteração e melhoria contínuas, é possível obter maior precisão para previsões mais confiáveis, resultando em viagens aéreas mais suaves e eficientes.