📃CA-AC-MPC

mpc

gpu

CA-AC-MPC: CUDA-Accelerated Actor-Critic Model Predictive Control

Published

June 1, 2026

Paper Link

🔍 Ping Review

🔍 Ping — A light tap on the surface. Get the gist in seconds.

🔔 Ring Review

🔔 Ring — An idea that echoes. Grasp the core and its value.

서론

로봇 제어에서 우리는 늘 두 마리 토끼를 쫓습니다. 하나는 모델 기반 최적 제어(MPC) 가 주는 구조적 안정성과 제약 조건 처리 능력이고, 다른 하나는 강화학습(RL) 이 주는 유연성과 과제 중심의 성능입니다. MPC는 “다음 몇 스텝 동안 어떻게 움직여야 비용이 최소가 될까?”를 매 순간 풀어내지만, 사람이 직접 비용 함수를 정교하게 설계해야 하고 모델이 정확해야만 잘 동작합니다. RL은 비용 함수를 손으로 짜지 않아도 보상 신호만으로 정책을 학습하지만, 수백만 번의 시뮬레이션이 필요하고 제약 조건을 보장하기 어렵습니다.

AC-MPC(Actor-Critic Model Predictive Control) 는 이 둘을 결합한 하이브리드 패러다임입니다. 핵심 아이디어를 비유하자면, MPC를 액터(actor) 신경망의 마지막 층으로 끼워 넣는 것입니다. 신경망이 “이번 상황에서는 이런 비용 함수가 좋겠다”라고 비용 계수 (C_t, c_t)를 출력하면, 그 비용을 받아 MPC가 실제 제어 입력을 풀어냅니다. 그리고 이 MPC 층을 미분 가능(differentiable) 하게 만들어 RL 손실의 그래디언트가 MPC를 거꾸로 통과해 신경망까지 흘러가게 합니다. 즉, “무엇을 최적화할지(비용)”는 RL이 학습으로 정하고, “어떻게 푸는지(최적화)”는 MPC가 책임집니다.

문제는 속도입니다. 일반적인 MLP 정책은 한 번의 순방향 패스(feed-forward)면 끝이지만, AC-MPC는 매 정책 평가마다 최적화 문제를 풀어야 하고, 학습 중에는 솔버를 거꾸로 미분까지 해야 합니다. 한 번의 학습 과정에서 MPC를 수백만 번 풀게 되니, 학습과 추론 모두 표준 MLP보다 훨씬 느려집니다.

이 논문(ICUAS 2026, 나폴리 페데리코 II 대학 PRISMA Lab)이 주목한 지점이 흥미롭습니다. 저자들은 이 병목이 GPU의 원시 연산 처리량(throughput) 문제가 아니라, 커널 실행 오버헤드(kernel launch overhead) 문제라고 진단합니다. 로봇 제어에서 상태/제어 차원(n_x, n_u)은 보통 작거나 중간 규모(가령 100 미만)라서, 개별 연산 자체는 몇 마이크로초면 끝납니다. 그런데 기존 PyTorch 기반 구현(mpc.pytorch)은 예측 지평선 T에 대해 Python 레벨 for 루프를 돌면서 단계마다 O(T)번의 GPU 커널을 띄웁니다. 비유하자면, 작은 짐을 수백 번 나르는데 매번 트럭 시동을 새로 거는 셈입니다. 짐을 옮기는 시간보다 시동 거는 시간이 더 길어집니다.

CA-AC-MPC의 한 줄 요약: 수학적 정식화는 그대로 두고, iLQR 솔버를 단 3개의 융합 CUDA 커널(fused kernel) 로 재구성해 이 “시동 거는 오버헤드”를 직접 제거한다. 그 결과 솔버는 1~2 자릿수(orders of magnitude) 빨라지고, AC-MPC를 실용적인 학습 속도로 끌어내립니다.

방법

경제적 MPC와 2차 비용 근사

먼저 토대가 되는 경제적 MPC(economic MPC) 를 봅시다. 이산 시간 동역학 x_{t+1} = f(x_t, u_t) 위에서 유한 지평선 최적 제어 문제(OCP)는 다음과 같습니다.

\min_{u_0, \dots, u_{T-1}} \sum_{t=0}^{T-1} \ell_t(x_t, u_t) + V_f(x_T) \quad \text{s.t.} \quad x_{t+1} = f(x_t, u_t),\; u_t \in \mathcal{U},\; x_0 = x_{\text{init}}

매 샘플링 시점마다 이 문제를 풀고, 최적 시퀀스 중 첫 번째 입력 u_0^\star 만 적용한 뒤 다음 스텝에서 다시 푸는 것이 바로 receding horizon 방식입니다.

표준 추적(tracking) MPC는 비용 \ell_t를 “목표 궤적에서 얼마나 벗어났나”를 재는 양의 정부호 2차 함수로 잡습니다. 하지만 드론 레이싱처럼 “랩 타임 최소화” 같은 과제 중심 목표는 본질적으로 희소하거나(sparse), 비매끄럽거나(non-smooth), 미분 불가능합니다. 그래서 저자들은 비용을 2차 대리 함수(quadratic surrogate) 로 근사합니다. z_t = [x_t^\top, u_t^\top]^\top \in \mathbb{R}^{n_x + n_u}로 두면,

\ell(z_t) \approx \frac{1}{2} z_t^\top C_t z_t + c_t^\top z_t

여기서 C_t는 양의 준정부호 비용 행렬, c_t는 선형 비용 계수입니다. 이렇게 하면 목표가 매끄러워지고 (C_t, c_t)에 대해 미분 가능해집니다. 이게 핵심입니다. 손으로 고정해 둔 계수는 상황마다 일반화하지 못하니, 신경망이 매 시점·매 상황마다 (C_t, c_t)를 동적으로 출력하게 만드는 것이죠.

액터-크리틱 구조

RL 부분은 표준적인 actor-critic을 PPO(proximal policy optimization)로 학습합니다. 크리틱은 TD(temporal difference) 오차로 가치 함수를 추정합니다.

\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)

액터는 어드밴티지 A_\phi(s_t, a_t) \approx \delta_t를 성능 신호로 삼아 정책 그래디언트로 업데이트됩니다.

\nabla_\theta J(\pi_\theta) = \frac{1}{N} \sum_{i=1}^{N} \sum_{t=1}^{L} \nabla_\theta \log \pi_\theta(a_t^i \mid s_t^i)\, A_\phi(s_t^i, a_t^i)

AC-MPC에서 액터의 마지막 층이 바로 MPC입니다. 학습 시에는 탐험을 위해 MPC 해 주변에서 확률적으로 행동을 샘플링하고, 배포 시에는 결정론적 MPC 해를 그대로 적용합니다.

flowchart LR
    S["State x_t"] --> NN["Actor MLP<br/>(2x512, ReLU)"]
    NN -->|"cost params (C_t, c_t)"| MPC["CA-DiffMPC layer<br/>(iLQR, K iters)"]
    MPC -->|"u*_t"| ENV["Drone dynamics f"]
    ENV -->|"reward r_t"| CRITIC["Critic MLP<br/>(value V)"]
    CRITIC -.->|"advantage / PPO loss"| NN
    MPC -.->|"implicit diff (KKT)"| NN
    ENV --> S

미분 가능 MPC: 암시적 미분

MPC 층을 거꾸로 미분하는 두 가지 길이 있습니다. 하나는 솔버 반복을 그대로 풀어헤쳐(unrolling) 자동 미분하는 것인데, 계산 비용이 크고 수치적으로 불안정합니다. 이 논문이 택한 길은 암시적 미분(implicit differentiation) 으로, 수렴한 해에서 KKT 최적성 조건을 미분해 그래디언트를 얻습니다. 이렇게 하면 전체 계산 그래프를 저장할 필요가 없고, 백워드 패스가 솔버 반복 횟수와 무관해집니다. 외부 손실 L에 대한 (C_t, c_t)와 x_{\text{init}}의 그래디언트가 보조 선형 시스템 한 번으로 복원됩니다.

CA-DiffMPC: 3-커널 융합

여기가 이 논문의 진짜 기여입니다. 순방향 솔버는 제어 제약을 다루는 control-limited iLQR(Tassa et al., 2014)을 따릅니다. 풀려는 박스 제약 문제는 다음과 같습니다.

\min_{x_t, u_t} \sum_{t=0}^{T-1} \frac{1}{2} z_t^\top C_t z_t + c_t^\top z_t \quad \text{s.t.}\quad x_{t+1}=f(x_t,u_t),\; u_{\min} \le u_t \le u_{\max},\; x_0 = x_{\text{init}}

기존 mpc.pytorch는 각 iLQR 단계(선형화, Riccati 백워드, 라인서치 롤아웃)를 지평선 T에 대한 Python for 루프로 돌려 단계·반복마다 O(T)개의 커널을 띄웁니다. 저자들은 이를 iLQR 반복당 정확히 3개의 융합 커널로 압축합니다.

Rollout & linearization 커널: 현재 공칭 입력으로 상태 롤아웃 x_{t+1}=f(x_t,u_t)를 계산하고, 해석적 야코비안 A_t = \partial f / \partial x \in \mathbb{R}^{n_x \times n_x}, B_t = \partial f / \partial u \in \mathbb{R}^{n_x \times n_u}를 모든 배치·시점에 대해 한 번에 구합니다. 해석적 미분이라 autograd 그래프를 저장하지 않아 메모리도 절약됩니다.
Backward pass 커널 (with input bounds): Riccati 재귀로 피드백/피드포워드 게인을 구해 \delta u_t = K_t \delta x_t + k_t를 얻습니다. 박스 제약이 있으면 단계별로 박스 제약 2차 부분 문제를 CUDA에서 풉니다. 시간 방향으로는 순차적이지만 배치 방향으로 병렬화합니다.
Forward pass 커널 (with line-search): 라인서치 계수 \alpha \in \{1.0, 0.5, 0.25, 0.1\} 후보들을 병렬로 평가해, 아핀 피드백 업데이트를 적용하고 동역학을 롤아웃해 비용을 잰 뒤 가장 좋은 후보를 선택합니다.

의사코드로 보면 다음과 같습니다.

Algorithm: CA-AC-MPC deployment
Require: actor pi_theta, dynamics f, horizon T, max iter K, bounds U
1: init CA-DiffMPC backend
2: for t = 0, 1, 2, ... do
3:    observe state x_t
4:    (C, c)_{0:T-1} <- pi_theta(x_t)            # cost params from actor MLP
5:    (X0, U0) <- Rollout(x_t, f)
6:    for k = 1 ... K do
7:        (A, B, l)_{0:T-1} <- LQ(f, (C,c), X_{k-1}, U_{k-1})   # kernel 1: linearize
8:        (K, kff)_{0:T-1}  <- FBP((A,B,l), U)                 # kernel 2: fused backward
9:        (X_k, U_k)        <- FFP(x_t, U_{k-1}, (K,kff))      # kernel 3: fused forward + line-search
10:       if Converged(X_k, U_k) then break
11:   end for
12:   u*_t <- U_k[0]                              # receding horizon: apply first input
13:   apply u*_t to system
14: end for

중요한 점은 수학적 정식화와 암시적 미분 타깃이 기존 DiffMPC와 완전히 동일하다는 것입니다. 기여는 순수하게 아키텍처적입니다. 시점별 Python 루프를 반복당 3개의 호라이즌 독립적인 CUDA 커널로 바꾼 것이죠. 결과물을 솔버 단독으로는 CA-DiffMPC, AC-MPC에 통합하면 CA-AC-MPC라 부릅니다.

실험

하드웨어는 Intel Core i9-13900K CPU + NVIDIA RTX A6000 GPU입니다. 과제는 SplitS 트랙을 도는 민첩한 드론 레이싱(원 트랙 형상이 비공개라 설명 기반으로 재구성)입니다. 평가는 네 가지 지표 M_1~M_4로 나뉘며, 지평선 T \in \{2, 5, 10\}와 iLQR 반복 K \in \{1, 5, 10\}를 가로질러 측정합니다. 액터/크리틱 모두 512 유닛 2층 ReLU MLP이고, 액터는 시그모이드 출력으로 비용 계수를 스케일·바운드합니다.

M_1 — 솔버 단독 지연 (Table II)

호버링 안정화 과제에서 제어 업데이트 1회 계산 시간(ms)을 측정해 baseline DiffMPC와 비교합니다.

Batch B	T	CA-DiffMPC 순방향	DiffMPC 순방향	CA-DiffMPC 역방향	DiffMPC 역방향
1	2	0.93	9.92	0.32	4.81
1	10	1.08	41.0	0.80	9.16
1	50	1.84	492	2.35	30.1
256	2	1.21	25.4	0.38	9.71
256	10	1.68	90.3	0.87	14.5
256	50	4.00	674	2.60	37.3

해석: 단일 인스턴스 T=50에서 순방향이 492ms → 1.84ms로 약 267배, 배치 256·T=50에서 674ms → 4.00ms로 약 168배 빨라집니다. 결정적으로, baseline DiffMPC는 T가 커질수록 시간이 거의 선형~초선형으로 폭증하지만(O(T) 커널), CA-DiffMPC는 지평선에 거의 둔감합니다. 이게 바로 “커널 수가 상수”라는 설계의 효과입니다.

M_2 — 학습 시간 (Table III)

전체 스택의 학습 시간 비교입니다. 다만 저자들은 공개 AC-MPC 코드베이스에서 지속적인 메모리 누수를 발견해(autograd 클래스 메타데이터 누적 + 그래디언트 추적 켜진 채로 iLQR 루프 실행) 패치 후에야 baseline을 수렴시킬 수 있었습니다.

방법	T	학습 시간
AC-MLP	–	16m:18s
AC-MPC (원본)	2	2h:15m:03s (K{=}5)
CA-AC-MPC	2	21m:22s (K{=}1) / 27m:32s (K{=}5) / 30m:30s (K{=}10)
CA-AC-MPC	5	21m:55s / 37m:03s / 29m:01s
CA-AC-MPC	10	21m:34s / 30m:29s / 33m:22s

해석: 원본 AC-MPC는 2시간 15분이 걸리던 학습이 CA-AC-MPC에서는 약 27분으로 줄어 약 5.4배 빨라집니다. 순수 MLP(16분)와 비교해도 오버헤드가 약 1.3배에 불과합니다. 원본 AC-MPC가 MLP 대비 약 30배였던 것과 극명하게 대비됩니다.

M_3 — 추론 지연 (Table IV)

방법	T	K=1	K=5	K=10
AC-MLP	–	0.245 ± 0.01 ms
AC-MPC	2	–	11.6 ± 0.9 ms	–
CA-AC-MPC	2	1.26 ± 0.06	1.26 ± 0.06	1.26 ± 0.07
CA-AC-MPC	5	1.43 ± 0.08	2.39 ± 0.08	2.32 ± 0.17
CA-AC-MPC	10	1.60 ± 0.01	2.83 ± 0.10	2.99 ± 0.30

해석: baseline AC-MPC(T{=}2, K{=}5)의 11.6ms 대비 CA-AC-MPC는 1.26ms로 약 10배 빠릅니다. 지평선이 길고 반복이 많을수록 격차는 더 벌어집니다. 흥미롭게도 T{=}2에서는 K가 늘어도 추론 시간이 거의 1.26ms로 일정한데, 이는 커널 수가 반복과 무관하게 상수라는 점과 일찍 수렴(early convergence)이 작동함을 시사합니다.

M_4 — 과제 성능 / 랩 타임 (Table V)

방법	T	K	랩 타임 [s]
AC-MLP	–	–	5.32
CA-AC-MPC	2	5	5.26
CA-AC-MPC	2	10	5.10
CA-AC-MPC	5	5	4.98

해석: 모든 정책이 약 20 m/s의 최고 속도에 도달해 플랫폼의 동역학 한계 근처에서 비행합니다. CA-AC-MPC(T{=}5, K{=}5)는 4.98초로 AC-MLP(5.32초)보다 빠르며, 반복 K가 늘수록 궤적이 더 매끄러워집니다. 정성적으로는 게이트 2~4 구간(split-S 직전)에서 MPC 정책이 더 높은 속도를 유지하는 반면, MLP는 웨이포인트 접근 시 감속하는 경향을 보입니다. 단, 절대 랩 타임은 트랙 재구성 때문에 문헌 값과 직접 비교하지 않습니다.

비판적 고찰

강점

정확한 문제 진단: “GPU 처리량이 아니라 커널 실행 오버헤드가 병목”이라는 통찰이 핵심입니다. 로봇 제어의 작은~중간 규모 문제에서 시간 병렬화가 오버헤드를 상쇄하지 못한다는 점을 정면으로 공략했습니다. 이는 시간 병렬 associative scan(legged locomotion, [13])이나 SQP+PCG 기반 GPU DiffMPC([14]) 같은 알고리즘 레벨 가속과 차별화되는 시스템/구현 레벨 접근입니다.
수학적 동등성 보존: 정식화와 암시적 미분을 그대로 두고 구현만 바꿨기 때문에, 성능 저하 없이 속도만 얻는다는 주장이 설득력 있습니다.
재현성: 코드를 공개했고, baseline의 메모리 누수까지 정직하게 패치·보고했습니다.
임베디드 잠재력: 호라이즌 독립적 상수 커널 패턴은 NVIDIA Jetson Orin 같은 플랫폼에서 디스패치 오버헤드 절감에 유리할 것으로 보입니다.

약점 및 한계

공정한 비교의 불가능: baseline AC-MPC가 공개 저장소 메모리 누수로 수렴하지 못해, M_4에서 like-for-like 폐루프 비교가 불가능했습니다. 비교는 주로 AC-MLP를 상대로 이뤄졌고, 원본 AC-MPC와의 직접 비교는 단일 수렴 케이스에 국한됩니다.
트랙 재구성: 원 SplitS 형상이 비공개라 설명 기반으로 재구성했고(게이트 높이는 특히 불확실), 절대 랩 타임을 문헌과 비교할 수 없습니다. 즉 “state-of-the-art”라는 주장은 동일 환경 내 상대 비교에 한정됩니다.
긴 지평선에서의 불안정: T{=}10이면 MPC가 140개의 최적화 변수를 예측해야 하는데, 단순 피드포워드 MLP는 시간적으로 일관된 비용 스케줄을 출력하지 못해 학습이 불안정해지고 수렴에 실패했습니다. 가장 안정적인 결과는 T{=}2, 5에서만 나왔습니다. (저자들은 move-blocking이나 시계열 아키텍처를 해법으로 제안합니다.)
상태 제약 미지원: 박스 제약은 iLQR/DDP 업데이트 안에서 처리하지만, 일반 상태 제약은 미분 가능 배리어/페널티 항으로만 다뤄 하드 제약을 보장하지 못합니다. 이는 액터가 과제 최적성과 암시적 제약 만족을 동시에 학습해야 하는 부담을 줍니다.
하드웨어 검증 부재: 실제 드론/임베디드 GPU 검증은 향후 과제로 남았고, 평가는 모두 시뮬레이션입니다.
(추측) 보고된 가속 배수의 상당 부분은 baseline mpc.pytorch가 GPU 친화적으로 작성되지 않은 점에서 비롯됐을 수 있어, 더 잘 최적화된 baseline이라면 격차가 줄어들 여지가 있습니다.

관련 연구와의 위치: 미분 가능 최적화 층의 계보(OptNet [6], DiffMPC [7], mpc.pytorch [8])와 AC-MPC([5], [9]) 위에 서 있으며, GPU 가속이라는 점에서 primal-dual iLQR([13])·SQP 기반 GPU DiffMPC([14])와 같은 흐름이지만, 이들이 알고리즘 차원의 병렬성을 노린 반면 이 논문은 커널 융합으로 디스패치 오버헤드를 직접 제거한다는 점에서 상보적입니다.

요약 및 결론

CA-AC-MPC는 미분 가능 MPC를 액터-크리틱에 끼워 넣을 때 발생하는 가장 큰 병목, 즉 커널 실행 오버헤드를 정확히 겨냥합니다. iLQR을 반복당 3개의 융합 CUDA 커널(롤아웃·선형화 / 박스 제약 Riccati 백워드 / 라인서치 포워드)로 재구성한 CA-DiffMPC가 핵심 기여이며, 수학적 정식화와 암시적 미분은 그대로 보존합니다.

수치적으로, 솔버 단독으로 단일 인스턴스에서 순방향·역방향 최소 1자릿수, 배치에서 최소 20배 이상 가속됩니다. 그 결과 전체 학습 시간은 AC-MLP 대비 약 30%(1.3배) 증가에 그쳐, 원본 AC-MPC의 약 30배와 극적으로 대비됩니다(약 5.4배 학습 가속). 추론은 약 10배 빨라지고(M_3), 드론 레이싱 랩 타임은 4.98초로 MLP(5.32초)를 능가하며 약 20 m/s의 동역학 한계 근처 비행을 보존합니다(M_4).

요컨대 이 연구는 “알고리즘을 바꾸지 않고 구현만 바꿔도, 미분 가능 MPC를 실용적 학습 속도로 끌어내릴 수 있다”는 점을 분명히 보여줍니다. 남은 과제는 긴 지평선에서의 비용 일관성(시계열 아키텍처), 하드 상태 제약, 그리고 실제 임베디드 GPU에서의 하드웨어 검증입니다. 미분 가능 MPC를 로봇에 올리려는 실무자에게는, 시스템 레벨 최적화가 알고리즘 혁신만큼이나 큰 레버리지를 줄 수 있다는 실용적 교훈을 남기는 논문입니다.