💬 NLP

LLM4Delay: Flight Delay Prediction via Cross-Modality Adaptation of Large Language Models and Aircraft Trajectory Representation

The paper proposes LLM4Delay, a novel framework that enhances flight delay prediction by integrating textual aeronautical data with aircraft trajectory representations through a cross-modality adaptation strategy, thereby outperforming existing air traffic management systems.

Original authors: Thaweerath Phisannupawong, Joshua Julian Damanik, Han-Lim Choi

Published 2026-04-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Thaweerath Phisannupawong, Joshua Julian Damanik, Han-Lim Choi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are an air traffic controller standing in a busy control tower. Your job is to watch planes land and guess exactly when they will touch down and park at the gate. But the sky is chaotic. Planes are weaving through clouds, weather is changing, and sometimes a plane ahead gets stuck, causing a ripple effect that delays everyone behind it.

Traditionally, controllers (and the computers helping them) have tried to predict these delays using rigid spreadsheets. They look at a flight's schedule, the weather report, and maybe the path of one plane. It's like trying to predict traffic in a city by only looking at the speed of one car and ignoring the construction signs, the red lights, and the other 50 cars on the road. It often leads to wrong guesses.

This paper introduces LLM4Delay, a new "super-brain" system designed to fix this. Here is how it works, explained simply:

1. The Problem: The "Spreadsheet" Limit

Old systems are like rigid robots. They can only handle data if it fits into a specific box. If a weather report is too long or a plane's path is weird, the robot gets confused. They also usually only look at the plane they are currently tracking, ignoring the traffic jam happening around it.

2. The Solution: A "Super-Translator" Brain

The authors built a system that combines two powerful tools:

The "Reader" (Large Language Model): Think of this as a super-smart librarian who has read every aviation manual, weather report, and news article ever written. It understands text perfectly. It knows what "heavy rain" or "runway closed" means in a sentence.
The "Watcher" (Trajectory Encoder): This is a specialized camera that watches planes move. It understands the shape of a flight path, how fast a plane is turning, and how it's weaving through the sky.

The Magic Trick: The problem is that the "Reader" speaks human language, and the "Watcher" speaks "flight path math." They don't understand each other.
The paper's big innovation is a translator called Instance-Level Projection. Instead of trying to force the flight path into a text sentence (which is clumsy), this translator takes the whole meaning of a plane's movement and turns it into a "concept" the Reader can understand.

3. The "Concert" Analogy

Imagine the airport is a busy concert hall.

Old Systems are like a sound engineer listening to only one instrument (the soloist) and guessing when the song will end.
LLM4Delay is like a conductor who hears the entire orchestra.
- It listens to the soloist (the specific plane you are tracking).
- It listens to the rest of the band (other planes in the sky causing congestion).
- It reads the lyrics and sheet music (weather reports, NOTAMs, and flight schedules).
- It reads the crowd noise (past patterns of how planes usually behave).

By hearing everything at once, the conductor can predict exactly when the song will end with incredible accuracy.

4. How It Learns

The system doesn't start from scratch. It uses a "pre-trained" brain (a Large Language Model) that already knows how to understand language, and a "pre-trained" eye (a trajectory encoder) that already knows how to spot flight patterns.
The paper teaches these two experts to work together using a new method. Instead of forcing them to relearn everything, it just teaches them how to pass notes to each other efficiently. This makes the system fast and efficient.

5. Why It Matters

It's Flexible: If a new type of weather report comes out, the system can read it without needing to be reprogrammed.
It's Continuous: As a plane flies, the system updates its guess in real-time. If a new plane enters the sky and causes a jam, the system immediately says, "Oh, that plane will be 5 minutes late now," rather than sticking to an old, wrong guess.
It's Accurate: In tests, this system was much better at predicting delays than previous methods, often getting within one minute of the actual time.

The Bottom Line

LLM4Delay is like upgrading from a calculator to a seasoned pilot. It doesn't just crunch numbers; it "reads the room" (the sky), understands the context (weather and traffic), and uses its vast knowledge to tell air traffic controllers exactly when a plane will arrive, helping everyone on the ground prepare for the landing smoothly.

1. Problem Statement

Flight delays are a critical inefficiency in Air Traffic Management (ATM). While existing prediction models often rely on fixed-size tabular features (e.g., flight schedules, weather codes) or single-trajectory time-series data, they face significant limitations:

Rigidity: They require manual parsing of unstructured textual data (e.g., METAR, TAF, NOTAMs) into numerical features, losing semantic nuance.
Limited Context: They typically analyze a single aircraft's trajectory, failing to capture complex airspace congestion and interactions between multiple aircraft.
Modality Gap: Standard Large Language Models (LLMs) excel at text but cannot natively process time-series trajectory data, while traditional time-series models cannot interpret unstructured aeronautical text.

The paper focuses on post-terminal delay prediction: estimating the remaining flight duration from the moment an aircraft enters the Terminal Maneuvering Area (TMA) until it arrives at the gate. This is a critical task for Air Traffic Controllers (ATCs) to coordinate ground services.

2. Methodology: LLM4Delay Framework

The authors propose LLM4Delay, a multimodal framework that integrates a pretrained LLM with a pretrained trajectory encoder via a novel cross-modality adaptation strategy.

A. Data Representation

The input is formulated as a scenario $s_{i,t}$ containing:

Textual Prompts: Unstructured aeronautical data including flight details, METAR (current weather), TAF (forecast), and NOTAMs (operational notices).
Trajectory Data: Three distinct groups of time-series trajectories to model airspace conditions:
- Focusing Trajectory ( $X^f$ ): The target aircraft's path from TMA entry to the current time $t$ .
- Active Trajectories ( $X^a$ ): Paths of other aircraft currently in the TMA, representing real-time congestion.
- Prior Trajectories ( $X^p$ ): Completed historical paths of other aircraft, providing context on typical flow patterns.

B. Architecture

The framework consists of three main components:

Frozen Pretrained Components:
- Trajectory Encoder ( $f_{enc}$ ): A self-supervised pretrained model (e.g., TS2Vec) that compresses raw trajectory time-series into instance-level embeddings (320 dimensions). This captures high-level maneuvering semantics rather than raw point-by-point data.
- LLM Backbone ( $f_{llm}$ ): A frozen open-source LLM (e.g., Pythia-1B) that processes textual tokens.
Cross-Modality Adaptation (Instance-Level Projection):
- Instead of tokenizing raw time-series data (which forces the LLM to infer temporal logic from digits), the framework uses a lightweight MLP adapter ( $f_{xa}$ ) to project the instance-level trajectory embeddings directly into the LLM's embedding space.
- This allows the LLM to treat trajectory groups as semantic "tokens" alongside text, preserving the high-level meaning of the flight path.
Regression Head:
- A trainable MLP head takes the final hidden state of the LLM (summarizing the multimodal context) and outputs a scalar prediction for the remaining post-terminal duration ( $\Delta t_{post}$ ).

C. Training Strategy

Freezing: The LLM backbone and trajectory encoder are frozen to preserve pretrained knowledge and reduce computational cost.
Trainable Parameters: Only the cross-modality adapter ( $f_{xa}$ ) and the regression head ( $f_h$ ) are updated.
Loss Function: Smooth L1 Loss is used for robustness against outliers.

3. Key Contributions

LLM4Delay Framework: A novel multimodal architecture that unifies unstructured aeronautical text and multi-trajectory time-series data within a single LLM-based pipeline.
Instance-Level Projection: A cross-modality adaptation technique that maps pre-encoded, high-level trajectory semantics into the language modality. This contrasts with existing methods that rely on low-level tokenization or feature-wise patching, which fail to capture complex inter-aircraft dependencies.
Comprehensive Multimodal Dataset: Construction of a public dataset integrating flight schedules, METAR, TAF, NOTAMs, and ADS-B trajectory data for Incheon International Airport (2022).
Operational Relevance: The model supports continuous prediction updates as new data arrives, mimicking the real-time monitoring workflow of ATCs.

4. Experimental Results

The model was evaluated on 12 monthly datasets using Mean Absolute Error (MAE), Mean Squared Error (MSE), and $R^2$ scores.

vs. Baselines: LLM4Delay significantly outperformed traditional tabular models (Linear Regression, XGBoost) and trajectory-only deep learning models (LSTM, Transformer, TCN).
- Example: LLM4Delay achieved an average MAE of 1.1261 minutes, compared to 1.4569 for the best trajectory-only baseline (Inverted Transformer) and 2.8047 for the best tabular baseline (XGBoost).
vs. Adaptation Techniques: The proposed Instance-Level Projection outperformed other time-series-to-language adaptation methods (Tokenization, Patch Reprogramming, Segment Embedding).
- Tokenization methods (serializing raw numbers) performed poorly (MAE ~3.2), highlighting that LLMs struggle to infer temporal dynamics from raw digits without semantic pre-encoding.
Ablation Studies:
- Trajectory Encoder: The TS2Vec encoder yielded the best results, suggesting that hierarchical contrastive learning is optimal for capturing maneuvering semantics.
- LLM Backbone: Pythia-1B performed best among tested backbones, indicating that even small, English-centric LLMs can generalize well to aeronautical text when properly adapted.
- Context Importance: Removing trajectory data caused the largest performance drop (MAE increased to 3.32), confirming that airspace congestion is the dominant factor. However, removing textual data (weather/NOTAMs) also degraded performance, proving the complementary value of both modalities.
Visualization: Perturbation analysis showed that trajectory tokens in the input sequence carry the highest importance, though textual tokens provide critical supplementary context for specific scenarios (e.g., severe weather).

5. Significance and Impact

Operational Value: The framework enables ATCs to receive continuously updated delay estimates as aircraft enter the TMA, facilitating better coordination of ground services (taxiing, baggage, fueling).
Scalability: By freezing the heavy backbone models and only training lightweight adapters, the system is computationally efficient and can be easily scaled to larger, more capable LLMs in the future.
Generalizability: The approach demonstrates that treating complex, multimodal aviation data as a unified token sequence allows models to leverage the reasoning capabilities of LLMs for regression tasks, moving beyond rigid feature engineering.
KPI Alignment: The model directly supports ICAO Global Air Navigation Plan (GANP) Key Performance Indicators (KPIs) regarding terminal airspace time and taxi-in delays.

In conclusion, LLM4Delay represents a paradigm shift in flight delay prediction, moving from rigid, feature-engineered models to a flexible, semantic-aware framework that effectively leverages the complementary strengths of large language models and trajectory representation learning.