AI Grand Prix — AI Integration Plan

VADR-TS-001 compliance, training strategy, submission pipeline • Grounded in the official spec • v1.0 — 2026-03-31

This document is the definitive playbook for training, integrating, testing, and submitting the autonomous drone AI for the AI Grand Prix Virtual Qualifier. Every requirement traces back to the VADR-TS-001 specification (Issue 00.01, 2026-03-09). Every parameter value references the actual codebase. Follow it top-to-bottom.

1. VADR-TS-001 Compliance Checklist

Every spec requirement mapped to our implementation. Fix all GAP items before submission.

Spec Requirement	§	Status	Implementation / Fix
MAVLink v2 over UDP	4.1-4.2	DONE	`mavsdk_bridge.py` — `SimBridge.connect()` via `udpin://`
HEARTBEAT reception	4.3	DONE	`connection_state()` async stream, waits for HEARTBEAT before race
ATTITUDE telemetry	4.3, 4.5	DONE	`_subscribe_attitude()` → Euler angles + angular rates
HIGHRES_IMU telemetry	4.3, 4.5	DONE	`_subscribe_imu()` → body-frame accel + gyro
ODOMETRY telemetry	4.3	DONE	`_subscribe_odometry()` → NED position + velocity
SET_POSITION_TARGET_LOCAL_NED	4.3	DONE	`send_velocity_ned()`, `send_velocity_body()`, `send_position_ned()`
SET_ATTITUDE_TARGET	4.3	DONE	`send_attitude()`, `send_attitude_rate()`
TIMESYNC handling	4.3	GAP	Mentioned in docstring but no subscription. Fix: add `_subscribe_timesync()` or verify MAVSDK handles transparently.
Python 3.14.2 runtime	5.1	PARTIAL	Code runs on 3.14 but uses `asyncio.ensure_future()` (deprecated). Fix: replace with `asyncio.create_task()`.
120 Hz physics rate	4.4	DONE	`race_config.py` `command_hz=120.0`
50–120 Hz command rate	4.4	DONE	Rate-limited async loop in `race_pipeline.py`
2 Hz minimum heartbeat	4.4	PARTIAL	MAVSDK auto-sends heartbeat. Verify: confirm with DCL sim that 2 Hz is maintained.
Local Cartesian only (no GPS)	3.3	DONE	NED frame throughout. No GPS references.
Forward-facing FPV camera only	3.4	DONE	`camera_adapter.py` single camera source
Vision → Perception → Planning → Control	5.3	GAP	Pipeline goes Perception → Control directly. Fix: integrate `trajectory_optimizer.py` as Planning layer, or document state machine as planning.
Max 8 minutes per run	8.3	DONE	`max_time_s=480.0` enforced in race loop
No human interaction	7	DONE	`race_main()` is fully autonomous
Navigate start → intermediate → finish gates	8.1-8.2	DONE	State machine: SEEK → APPROACH → TRANSIT → FINISHED
Dependency manifest	5.1	GAP	No `requirements.txt`. Fix: generate with pinned versions.

3 Critical Gaps: TIMESYNC subscription, Planning layer, asyncio.ensure_future() deprecation. Fix before any submission.

2 Moderate Gaps: Missing requirements.txt, heartbeat rate verification. Fix during Week 1.

2. Training Strategy — Three Tiers

Tier 1 — Vision Models (no simulator needed)

Train detection models offline using captured frames or synthetic data.

U-Net Gate Segmentation

python gate_segmentation.py train --data dataset_gates_seg

Parameter	Value
Architecture	GateSegNet (3→32→64→128→256 encoder)
Parameters	~3.7M
Loss	Dice + BCE combined
Optimizer	Adam, lr=1e-3
Epochs	100
Batch size	8
Input size	480 × 640
Export	`gate_seg.onnx` (opset 17)

Dataset: dataset_gates_seg/{train,val}/{images,masks}/
Masks: binary (white = gate, black = background)

YOLO Auto-Label → Train

# Step 1: auto-label from VQ1 color detection
python yolo-auto-label.py

# Step 2: train YOLOv8
python yolo-train.py train

# Step 3: export TensorRT
python yolo-train.py export

Parameter	Value
Base model	yolov8n (nano)
Epochs	150
Conf threshold	0.5
Export priority	.engine > .onnx > .pt

Auto-labeler uses ColorGateDetector to generate ground-truth bounding boxes from VQ1 highlighted-gate footage.

Tier 2 — Classical Controller (simulator needed)

The safe baseline for Round 1. Proportional pursuit controller with aggressive tuning.

Gain	Value	What it does	Tune if...
kp_yaw	50.0	Yaw snap to gate heading	Oscillates: lower. Sluggish: raise.
kp_pitch	30.0	Forward pitch authority	Nosedive: lower. Won't approach: raise.
kp_roll	25.0	Banking into turns	Roll oscillation: lower.
cruise_pitch	-25.0°	Forward tilt when gate far	Too fast/crash: reduce. Too slow: increase.
approach_pitch	-15.0°	Forward tilt near gate	Overshoot: reduce. Stalls: increase.
hover_thrust	0.50	Thrust to hold altitude	CALIBRATE FIRST. Descends: raise. Climbs: lower.
seek_yaw_rate	180°/s	Spin speed when searching	Blur kills detection: lower to 90-120.

hover_thrust=0.50 is uncalibrated. This is the #1 crash cause. Run the hover test BEFORE any race attempt. Tune in 0.02 increments.

# Test classical controller
python test_race_standalone.py

# With YAML config override
python race_pipeline.py my_config.yaml attitude

Tier 3 — RL Policy (advanced, needs training time)

# Phase A: privileged training
python rl_train.py train --steps 5000000

# Export to ONNX
python rl_train.py export

# Deploy in race pipeline
# Set controller to "rl" mode (requires code change in race_pipeline.py)

Critical gap: DroneRaceEnv currently uses privileged=True (ground-truth gate positions). Phase B requires modifying _get_obs() to feed real VisionPipeline detections. This is the hardest integration step.

Reward	Value	Purpose
Closer to gate	+1.0 per meter	Drive toward gate
Gate passage	+50.0	Reward transit
Crash	-100.0	Punish collision
Time penalty	-0.01 per step	Encourage speed

3. Integration Architecture

velocity

Timing Budget (120 Hz = 8.33ms per frame)

Stage	Target	Method
Camera capture	<1 ms	USB/CSI/sim pipe
U-Net inference	<5 ms	GPU (RTX/Jetson)
RANSAC corners + PnP	<2 ms	CPU (OpenCV)
Gate tracker	<0.1 ms	EMA update
State machine	<0.1 ms	Branch logic
Controller compute	<0.5 ms	Proportional math / ONNX inference
MAVLink send	<1 ms	Async UDP
Total	<8.7 ms	Fits 120 Hz with margin

Budget analysis: At 120 Hz we have 8.33 ms. The pipeline fits. If U-Net inference exceeds 5 ms (e.g., on Jetson), drop to 60 Hz vision + 120 Hz control by running vision every 2nd frame.

4. Submission Pipeline

Required files

From submit_check.py — these are packaged into submission.zip:

File	Purpose	Required
`race_pipeline.py`	Main orchestrator	Yes
`vision_pipeline.py`	Gate detection + PnP	Yes
`mavsdk_bridge.py`	MAVLink communication	Yes
`race_config.py`	Configuration	Yes
`gate_segmentation.py`	U-Net model + RANSAC	Yes (if mode=unet)
`camera_adapter.py`	Camera sources	Yes
`race_logger.py`	JSONL logging	Yes
`drone_mpc_foundation.py`	Schemas + MPC	Yes
`sim_drone.py`	Physics (standalone mode)	Optional
`rl_controller.py`	RL inference	Optional (if using RL)
`trajectory_optimizer.py`	Path planning	Optional
`gate_seg_best.pt`	U-Net weights	Yes (if mode=unet)
`policy.onnx`	RL policy weights	Optional (if using RL)
`requirements.txt`	Dependencies	Yes

Generate requirements.txt

mavsdk>=2.0
opencv-python>=4.8
numpy>=1.26
torch>=2.2
onnxruntime>=1.17
ultralytics>=8.1
stable-baselines3>=2.2
gymnasium>=0.29
casadi>=3.6
scipy>=1.12
pyyaml>=6.0

Config switch for DCL environment

# race_config.py ConnectionSettings
# Local simulation:
sim_url: "udpin://0.0.0.0:14540"
camera_source: "synthetic"

# DCL simulator:
sim_url: "udpin://0.0.0.0:14540"   # verify with competition docs
camera_source: "gazebo_pipe"        # or per DCL vision stream spec

Package and validate

python submit_check.py          # run all checks
python submit_check.py package  # create submission.zip

The validator checks syntax, imports, vision smoke test, controller smoke test, config validation, and code quality. It does NOT test live MAVLink connectivity.

5. Pre-Submission Validation Checklist

Standalone race test (no simulator)

python test_race_standalone.py

Expected: Completes gates in <480s. Detection rate >50%.

MAVSDK bridge test (requires PX4 SITL or DCL sim)

python mavsdk_bridge.py

Expected: Connects, hovers at 5m for 30s, prints NED position and command rate.

Verify command rate

In race loop output, confirm command_rate reads ≥50 Hz. Target: 120 Hz per race_config.py.

Verify 8-minute timeout

Confirm race_config.py max_time_s=480.0. Run a deliberate slow test — pipeline should terminate at 8:00.

Check vision FPS

python vision_pipeline.py

Expected: Color mode >200 FPS, U-Net >100 FPS (GPU), YOLO >60 FPS (GPU).

Validate submission package

python submit_check.py package

Expected: 0 failures, creates submission.zip. Verify zip contents include all required files + weights.

6. Performance Optimization Targets

Metric	Target	Current	Tuning Knob
Vision latency (U-Net)	<5 ms	~5ms GPU	Reduce `base_ch` or use TensorRT
Vision latency (YOLO)	<12 ms	~12ms GPU	Use `.engine` TensorRT format
Control loop rate	120 Hz	120 Hz (config)	`command_hz` in race_config.py
Gate detection rate	>80% of frames	varies	HSV range, U-Net training data, confidence threshold
Transit detection	<1.5m + 3 closing frames	1.5m default	`transit_distance`
Max speed	30 m/s	30 m/s (config)	`safety.max_speed`
Max tilt	70°	70° (config)	`safety.max_tilt`
PnP distance accuracy	<10% error at 15m	depends on corners	U-Net RANSAC >> bbox corners
EMA tracker alpha	0.65	0.65	Higher = faster, noisier
hover_thrust	calibrated	0.50 (uncalibrated!)	MUST tune per sim

Lap Time Targets

Based on typical DCL indoor course (~11 gates, ~160m total track):

Tier	Lap Time	Avg Speed	Strategy
Conservative (Round 1 pass)	60–90s	2–3 m/s	Slow, safe, detect every gate
Competitive (top 50%)	30–45s	4–6 m/s	Aggressive pursuit, late braking
Top tier (podium)	<25s	7–10 m/s	Optimal trajectory + RL policy + racing line

7. Risk Matrix

Risk	L	I	Mitigation
hover_thrust miscalibrated	H	H	Run hover test first. Tune in 0.02 increments. Add auto-calibration that measures altitude error.
Sim-to-real gap (RL)	H	H	RL Phase B (vision-in-loop) + Phase C (domain rand). Classical controller as fallback.
`asyncio.ensure_future()` removed in 3.14	H	H	Replace with `asyncio.create_task()` at 4 call sites in mavsdk_bridge.py.
Unknown gate color in VQ1	M	H	Auto-detect dominant saturated color in first 10 frames. Multiple HSV presets available.
Timeout before finishing (8 min)	M	H	Monitor elapsed time. If >6 min and <50% gates, increase speed aggressiveness.
Camera stream not connected	M	H	`preflight_check()` verifies camera produces frames. Add retry logic.
TIMESYNC not handled	M	M	MAVSDK may handle transparently. If not, add `_subscribe_timesync()`.
Gate partially visible	M	M	U-Net handles partial gates. RANSAC works with incomplete contours.
False transit triggers	L	M	Predictive transit: `distance_closing_count ≥ 3` + 0.3s cooldown.
No requirements.txt	H	M	Generate and include in submission. See Section 4.

8. Timeline — 8-Week Plan

Weeks 1–2: Baseline

Connect to DCL simulator
Fix asyncio.ensure_future() → create_task()
Add TIMESYNC subscription
Generate requirements.txt
Calibrate hover_thrust
Tune kp_yaw, cruise_pitch, approach_pitch
Pass submit_check.py all checks
Goal: drone navigates gates at slow speed

Weeks 3–4: Vision

Capture ~1000 VQ1 frames
Run yolo-auto-label.py
Train U-Net + YOLO
Export to ONNX / TensorRT
Benchmark: U-Net <5ms, YOLO <12ms
Detection rate >80% on sim frames
Goal: trained vision models integrated

Weeks 5–6: RL + Planning

RL Phase A: 2–5M steps privileged
Modify DroneRaceEnv for vision-in-loop
RL Phase B: 2M steps with real vision
Integrate TrajectoryOptimizer
Export RL policy to ONNX
A/B test: classical vs RL
Goal: RL policy outperforms baseline

Weeks 7–8: Submit

End-to-end test with DCL sim
Full 8-min race, all gates
Multiple runs for consistency
Final parameter tune
submit_check.py package
Submit submission.zip
Goal: competitive submission

Bottom line: The classical controller (Tier 2) is your safe Round 1 pass. Vision training (Tier 1) improves PnP accuracy. RL (Tier 3) is the path to podium. Do them in order — never skip the baseline.