mpc-b747-step-response

TorchMPC with Learned Dynamics (OneStepMLP) for Boeing 747 Pitch Angle Control

<div align="center">

Model Predictive Control with Neural Network Dynamics for Longitudinal Aircraft Control

</div>

Model Description

This model combines Model Predictive Control (MPC) with a learned neural network dynamics model (OneStepMLP) to control the pitch angle (θ) of a Boeing 747 aircraft in a longitudinal flight dynamics simulation. The approach first learns the aircraft dynamics from exploration data, then uses gradient-based MPC optimization to compute optimal control actions for reference tracking.

Key Features

• Data-driven dynamics: Learns one-step transition model f(x, u) → Δx from exploration data
• Gradient-based MPC: Differentiable optimization through learned dynamics
• Step response optimization: Custom cost function for overshoot/settling time minimization
• Warm-starting: Efficient action sequence initialization across timesteps

Intended Uses

• Primary Use: Automatic pitch angle tracking and stabilization for Boeing 747 aircraft simulation
• Research Applications: Benchmarking learning-based MPC algorithms for aerospace control systems
• Educational: Learning MPC concepts with neural network dynamics in aerospace applications
• Hybrid Control: Can be combined with analytical models for robust flight control

Model Architecture

Dynamics Model (OneStepMLP)

The dynamics model predicts state transitions using a multi-layer perceptron:

Total Parameters: ~70K

MPC Controller

State Space

The observation vector consists of 4 states representing the longitudinal dynamics:

Action Space

Training Details

Data Collection

Dynamics Training

MPC Cost Weights

Step Response Cost Configuration

Environment Configuration

Training Infrastructure

• Hardware: CUDA GPU (recommended) / CPU
• Framework: PyTorch 2.0+
• Compile Mode: reduce-overhead (CUDA only)

Evaluation Results

Performance Metrics

Integral Criteria

Step Response Characteristics

The MPC controller demonstrates good step tracking performance with:

• ✅ Very low overshoot (~0.27%)
• ✅ Fast settling time (1.4s)
• ✅ Quick rise time (0.8s)
• ⚠️ Some oscillations (5 cycles)
• ⚠️ Small static error (0.038)

Usage

Installation

pip install tensoraerospace

Quick Start

import numpy as np
import gymnasium as gym
import torch
from tensoraerospace.signals.standart import unit_step
from tensoraerospace.agent.mpc import MPCAgent

def pick_device() -> str:
    if torch.cuda.is_available():
        return "cuda"
    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
        return "mps"
    return "cpu"

# Setup environment
DT = 0.1
TN = 20.0
N_STEPS = int(TN / DT) + 1
T = np.arange(N_STEPS, dtype=np.float32) * DT

# Create step reference signal (1 degree step at t=5s)
reference_signal = unit_step(
    tp=T,
    degree=1.0,
    time_step=5.0,
    output_rad=True,
).reshape(1, -1)

env = gym.make(
    "LinearLongitudinalB747-v0",
    number_time_steps=N_STEPS,
    initial_state=np.array([[0.0], [0.0], [0.0], [0.0]], dtype=np.float32),
    reference_signal=reference_signal,
    dt=DT,
)

# Load pretrained agent
agent = MPCAgent.from_pretrained("TensorAeroSpace/torchmpc-mlp-b747-step-response")
agent.env = env
agent.to_device(pick_device())

# Run evaluation
_ = env.reset()
agent.reset()

ref_theta_rad = reference_signal[0]
x_ref = np.zeros((21, 4), dtype=np.float32)  # horizon + 1

for step in range(N_STEPS - 2):
    k = int(env.unwrapped.current_step)
    x0 = np.asarray(env.unwrapped.model.xt, dtype=np.float32).reshape(-1)
    
    # Set reference for horizon
    ref_k = float(ref_theta_rad[min(k, len(ref_theta_rad) - 1)])
    x_ref[:, 3] = ref_k
    
    action = agent.select_action(x0, x_ref=x_ref)
    obs, reward, terminated, truncated, info = env.step(action)
    
    if terminated or truncated:
        break

Custom Dynamics Training

# Collect exploration data
agent.collect_data(
    num_episodes=1500,
    max_steps=199,
    exploration="signals",
    signal_kinds=["random_steps", "sinusoid", "chirp", ...],
    dt=0.1,
    action_amplitude_frac=1.0,
)

# Train dynamics model
metrics = agent.train_dynamics(
    epochs=120,
    batch_size=2048,
    loss="mse",
)
print(f"Final dynamics loss: {metrics['loss']:.2e}")

Comparison with Other Methods

Limitations

• Fixed Aircraft Model: Trained specifically on Boeing 747 longitudinal dynamics; may not generalize to other aircraft
• Step Reference Focus: Optimized for step reference tracking; performance on other signal types may vary
• Simulation Gap: Trained in simulation; real-world deployment would require additional validation
• Computational Cost: MPC optimization at each step requires more computation than pure RL policies
• Linear Dynamics: Based on linearized aircraft model around trim conditions
• Some Oscillations: The controller exhibits 5 oscillation cycles during settling

Ethical Considerations

• Not for Real Flight Control: This model is for research and educational purposes only. It should NOT be used for actual aircraft control systems without extensive testing, certification, and regulatory approval.
• Simulation Only: All training and evaluation performed in simulation environments.

Citation

If you use this model in your research, please cite:

@software{tensoraerospace2024,
  title = {TensorAeroSpace: Advanced Aerospace Control Systems \& Reinforcement Learning Framework},
  author = {TensorAeroSpace Team},
  year = {2024},
  url = {https://github.com/TensorAeroSpace/TensorAeroSpace},
  license = {MIT}
}

Model Card Authors

TensorAeroSpace Team

Model Card Contact

• GitHub: TensorAeroSpace/TensorAeroSpace
• Documentation: tensoraerospace.readthedocs.io
• Hugging Face: TensorAeroSpace