Two-track training plan
for VQ1 + VQ2.

§ 01Target architecture

References: MonoRace (A2RL 2025 champion, TU Delft MAVLab) · Swift (Nature 2023, UZH) · SkyDreamer (ICLR 2025).

§ 02Step 0 — Register + monitor

§ 03Step 1 — VQ1 completion stack (ships first)

Deterministic detector + PnP + PID. No learning on critical path. VQ1 scores on completion, not time — a reliable zero-learning stack is the safest submission.

class VQ1CompletionPilot:
    def step(self, frame_bgr, telemetry):
        # 1) detect gates
        detections = self.det.infer(frame_bgr)
        if not detections:
            return self._search_fallback(telemetry)

        # 2) pick target: closest in-front gate with highest confidence
        target = self._select_target(detections, telemetry)

        # 3) keypoints + PnP
        corners = self.kp.infer(frame_bgr, target.bbox)
        rvec, tvec = solve_pnp_square(GATE_3D_1p5m, corners, self.K)

        # 4) body-frame gate pose
        gate_body = rotate_by_quat(tvec, telemetry.attitude_q)

        # 5) PID controller
        heading_err = atan2(gate_body.y, gate_body.x)
        throttle = self._thrust_curve(|gate_body|, gate_body.z)
        return throttle, roll, pitch, yaw

§ 04Step 2 — Swap PPO observation (required for VQ2)

Current Phase-3 PPO reads gate positions from course_map_test.json. That's not available in the real AIGP sim. Rebuild around signals the sim actually exposes:

# OLD (privileged — doesn't transfer):
obs = np.concat([
    drone_pos_ned,            # 3D · NOT AVAILABLE
    drone_vel_ned,            # 3D · NOT AVAILABLE
    gate_positions_ned[:2],   # 6D · NOT AVAILABLE
    ...
])

# NEW (detector + telemetry):
obs = np.concat([
    # Vision side (per frame)
    detected_gate_bbox_xywh,        # 4D · normalized [0,1]
    detected_gate_keypoints_xy,     # 8D · 4 corners
    detection_confidence,           # 1D
    frames_since_detection,         # 1D · decays
    # Telemetry side (from sim)
    attitude_quaternion,            # 4D
    body_rates,                     # 3D · roll/pitch/yaw rates
    body_accel,                     # 3D
    # History
    last_action,                    # 4D · T/R/P/Y
])  # Total: 28D

python train_apex.py policy                                    # default
python train_apex.py policy --observation-mode=privileged      # legacy (dev only)

§ 05Step 3 — Perception-aware reward (Swift's key insight)

Swift's single reward term teaches seek-attack behavior without a state machine. Adapted for detector-output obs: reward "gate near frame center at high confidence."

def perception_reward(detection):
    if detection is None:
        return -0.2                    # penalty for losing sight
    cx, cy = detection.bbox_center_normalized
    centered = 1.0 - 2.0 * np.hypot(cx - 0.5, cy - 0.5)
    return centered * detection.confidence

def step_reward(obs, detection, action, prev_action, crashed, gate_passed):
    r_progress   = 10.0 if gate_passed else 0.0
    r_perception = 0.5 * perception_reward(detection)
    r_smooth     = -0.1 * np.sum(np.abs(action - prev_action))
    r_crash      = -5.0 if crashed else 0.0
    return r_progress + r_perception + r_smooth + r_crash

§ 06Step 4 — Dataset expansion for VQ2

Current: 2,759 training images (dataset_gates_mega). Target: 10,000+ with domain randomization + hard negatives, because VQ2 adds lighting changes, 3D objects, and non-gated obstacles that can trigger false positives.

Albumentations pipeline stays unchanged (brightness, motion blur, occlusion, shadow).

§ 07Step 5 — Parallel sim instances for RL fan-out

AIGP update explicitly allows multiple sim instances on one box. Wrap the sim client in a SubprocVecEnv and run 8+ envs on the RTX 5080 host. Wall-clock should drop 6–8×.

from stable_baselines3.common.vec_env import SubprocVecEnv
from stable_baselines3 import PPO

def make_env(instance_id):
    def _init():
        return AIGPSimEnv(instance_id=instance_id, port=6000 + instance_id)
    return _init

env = SubprocVecEnv([make_env(i) for i in range(8)])
model = PPO("MlpPolicy", env, n_steps=2048, batch_size=512, ...)
model.learn(total_timesteps=10_000_000)

Caveat: active internet required per instance (anti-cheat). Budget bandwidth + make sure the sim's handshake supports parallel clients (confirmed in update, details TBD).

§ 08Retired (pre-2026-04-19)

§ 09VQ1 sim day-one checklist

§ 10What separates winners from losers

§ 11Key performance targets

§ 12Current codebase state