Portrait of Yang Hao

Yang Hao 杨豪

Model Quantization & Deployment Lead

QCraft (轻舟智航) · Perception ML-Infra

I take deep-learning models from training to production automotive chips. At QCraft I lead model quantization and on-device deployment for about 19 production driving and parking models: BEV perception, occupancy, vector maps, temporal tracking and end-to-end planning. They run on Horizon J5/J6M, NVIDIA Orin, Qualcomm and AXERA chips.

My work spans quantization algorithms (PTQ, QAT, quantization-aware distillation), bit-level numerical consistency across toolchains, latency modeling, and the platforms and release gates that make this repeatable. I lead a six-engineer team and am technical lead for bringing our urban NOA stack to a new chip family. Before QCraft I worked at Tencent Maps and Yitu Technology, and I studied pattern recognition at Beihang University.

  • Model quantization (PTQ / QAT / QAD)
  • Efficient on-device inference
  • End-to-end autonomous driving
  • ML infrastructure and tooling

Blue is the float output, orange the quantized one. My job is to keep the orange line on the blue one, on the chip.

≈19production models quantized and deployeddriving + parking
2 → 0.5points of quantization lossPTQ → QAT · five perception models
≤ 2 LSBworst-case LUT operator error600 modules · 85% fewer tables
0.7%on-board latency prediction error19.38 ms predicted · 19.25 measured
4,273production model conversionsbuild time 30–60 → 5 min
2 wk → 3–5 dper-model quantization adaptationlayered toolchain + AI auto-adaptation

What I Own

One pipeline from training to the vehicle, and the four layers I built on it. Each project below sits somewhere on this picture.

pipeline and the four layers I ownDEPLOYMENT PIPELINEFloat trainingshared backboneQuantizationPTQ · QAT · QADExport IRfixed-point opsMulti-chip buildone-clickAlignmenttraceable hopsBoard, vehiclelatency, road testsTHE FOUR LAYERS I OWNAlgorithmaccuracy within thehardware budgetscale-search PTQ · LSQ AutoQuant · distillationQAT · large-scale QAD · adaptive LUTsConsistencyevery mismatchtraceableFloat → QAT → in-house IR → LibTorch → HBIR → HBM → board, compared stage by stagePlatformone entry point forevery chipQNN Web · Horizon J5 / J6M / J6P · NVIDIA Orin · QualcommAXERA M95 / M97Governancenothing unverifiedshipsevidence-graded gates · feature flags · regression set of past failures · owner + backup per model

News

Experience

QCraft 轻舟智航

Oct 2022 – present

Model Quantization & Deployment Lead, Perception ML-Infra

Joined as Machine Learning Infrastructure Engineer; promoted to L5 in 2024; team lead since 2025.

Float-consistent quantization: four generations of method

  • Problem: Production tolerates almost no regression (an AEB target detected one frame late is a failure), yet QAT trained on the task loss alone shifts the precision/recall operating point, so what ships is effectively a retrained model.
  • Scale-search PTQ (2023, patent filed): searches quantization parameters in stages against cosine similarity to the float outputs: calibration method × parameter grid → layer-wise backward/forward search → layer-wise quantization. On a traffic-light detector, default calibration gave mAP 0.747 and layer-wise quantization restored it to 0.803 (float 0.800).
  • LSQ-based AutoQuant (2024) for CNN + Transformer hybrids (vector map, temporal tracking): learns step sizes, constrains weight drift with AdaRound-style rounding, and supervises with float intermediate features, with cross-layer equalization (CLE) and LayerNorm–Linear fusion applied first.
  • Distillation QAT → large-scale QAD (2025–2026): float model as teacher, PTQ model as the start, task loss plus feature/output distillation. On the end-to-end planner, single-variable experiments (25 key metrics, 388 shared scalars) showed that scene-boundary state reset, an independent teacher history and late-stage weight anchoring are all required.
  • Result: Quantization loss on five production perception models fell from about 2 points to about 0.5; the quantized end-to-end planner went to on-vehicle testing; model owners have started running auto-QAT releases themselves.

Quantization error accumulation in a prediction-planning model (QuestNet v3)

  • Problem: After quantization the model produced abnormal trajectories; PTQ and standard QAT both failed and a production delivery was blocked.
  • Per-layer and cumulative error analysis showed the error compounding through the deep layers; sensitive and robust layers are treated differently. Experiments ruled out “freeze some layers and fine-tune” in favor of two-stage quantization with full QAT.
  • Drawing on the chip's operator characteristics, moved the whole pipeline to INT16 for numeric headroom against the accumulation.
  • Result: Trajectory anomalies eliminated; merged to mainline and release-validated. “Mid-fusion models need full QAT” is now team practice.

Fixed-point numerical correctness: adaptive LUTs and layered alignment

  • Adaptive lookup tables: on the NPU, rsqrt, reciprocal, exp and sigmoid run as fixed-point piecewise LUTs. The algorithm measures error on the chip's actual fixed-point output codes (not a float approximation), keeps the original 6-table boundaries, recursively bisects the worst segment, and blocks export if the budget cannot meet the bound. Across 600 LUT modules in four production graphs: 0.217 LSB mean, 2 LSB max (uniform 126-table: 11,381 LSB max), with 85% fewer tables.
  • Layered alignment: Float → QAT → in-house IR → LibTorch → HBIR → HBM → on-board post-processing, each stage compared only with the previous one on identical inputs, so a mismatch has exactly one possible source. Pinned down an rsqrt LUT split point in a norm layer, an upsample align_corners mismatch and pose-precision bugs.
  • Release gates: results graded by evidence level (source / build / simulation / board / vehicle), default-off feature flags, and a regression set of past quantization failures re-run before every release; caught issues pre-release on three automaker programs.

Toolchain and platform: from one-click conversion to a quantization-deployment platform

  • QNN Web, a one-click multi-chip conversion service (gRPC front/back end, configs generated from the ONNX graph, TensorRT timing cache; later a job database, queueing and MCP endpoints for AI agents): 4,273 production conversions, build time from 30–60 min to about 5, about 80% less manual effort.
  • Split multi-chip quantization into a generic layer, an AI auto-adaptation layer and a platform layer; per-model adaptation went from about 2 weeks to 3–5 days. Led the team onto Qualcomm (model splitting and latency tuning; inference latency cut by more than 50%), TensorRT QDQ INT8 and VLM quantization on Horizon J6P.
  • Since Nov 2026, leading the target architecture of a platform-style quantization-deployment framework (design draft, roadmap to Q2 2027): fixed-point simulation as the single source of truth, seven versioned contracts (artifact identity, IR metadata, IO contract, golden IO, precision profile, target capability, thresholds) across the training, conversion and on-vehicle codebases, blocking gates at every hop, and a sensitivity × latency-cost loop that plans mixed precision.

Latency modeling, model architecture and training efficiency

  • Structural latency model: predicts on-board latency from module structure; the occupancy model was predicted at 19.38 ms and measured at 19.25 ms (0.7% error). It ruled out shipping “wider range + 10 Hz” before any code was written and confirmed that MapFormer query merging saves 2.1–3.3 ms.
  • OneModel phase 2 (in progress): one shared image backbone and neck for five perception tasks and 9 cameras, estimated to save 5–9 ms per frame. Backbone sized by PCA redundancy analysis of the five tasks' checkpoint features; pretraining weights synthesized by channel alignment plus a closed-form linear solve; quantization-friendly ReLU6 with surrogate gradients; receptive-field center offset fixed.
  • Migrated BEV occupancy training to PyTorch 2.x: 1.56 s → 0.71 s per iteration (−54%; V100, batch 16, AMP), 9% less GPU memory, scaling benchmarked from 1 to 112 GPUs.
  • End-to-end driving model architecture (design proposal, not yet trained): a camera-first, token-based design: 9 cameras tokenized through the shared encoder, a streaming transformer with pose-aware memory, a multi-mode plan head parameterized by curvature and acceleration knots, with a distill-then-INT8 path designed in from the start.

Team leadership and program delivery

  • Lead a 6-engineer quantization and deployment team (dotted-line from 2025, direct reports from 2026): an owner and a backup for each of about 19 production models, quarterly goals with P0/P1 priorities, work assigned by urgency × difficulty. In Q2 2026, with four production programs in parallel on a two-week release cadence, no release slipped because of quantization.
  • Technical lead since June 2026 for the AXERA chip program (validated on the M97 700-TOPS dev board; target chip M95, 350 TOPS): staged bring-up plan, model adaptation and quantization, road-test issue triage. The urban NOA v4 stack runs on test vehicles, with no frame drops on key models.
  • AI-assisted automation: a Feishu bot plus coding-agent skills adapt new model features for quantization (60 person-day project). Maintain a 33-page knowledge base, run monthly quantization sessions and coach engineers to independent model ownership.

Tencent Maps 腾讯地图

Jul 2021 – Oct 2022

Algorithm Engineer, Map Platform (CSIG)

  • Built a TensorRT INT8 quantization and deployment pipeline for cloud GPU models, with in-house quantization and conversion tools: cosine similarity above 0.999 to the float model, inference latency −20%, GPU utilization −10%, GPU memory −10%; saved roughly ¥3M in compute cost.
  • Designed the perception SDK for AR navigation: a multi-stream parallel framework with automatic profiling. Delivered 12 features in four months with CPU usage under 70%; shipped on the JMC CX743 production vehicle, whose data return feeds Tencent Maps updates.
  • Built the NBT evaluation platform, an internal web service for model and data management, algorithm evaluation and result sharing, with hooks for bad-case analysis and map-building visualization.
  • Optimized vehicle-side map-building and data-collection pipelines and ARM on-board CPU usage.

Yitu Technology 依图科技

Apr 2019 – Jul 2021

Algorithm Engineer

  • Built a C++ face-recognition engine that combines several models, tuning the combination strategy for throughput and recognition rate; deployed in projects including face-recognition metro entry in Guiyang.
  • Trained machine-translation models.
  • Quantized and deployed models on Yitu's QuestCore (求索) AI chip; developed quantization tools, accuracy evaluation and the model zoo.

Selected Projects

Each project has a detail page with the problem, the method step by step, and the results. All projects →

≤ 2 LSBworst-case error, 85% fewer tables

Adaptive lookup tables for non-linear operators

QCraft · 2026

An error-driven segmentation algorithm for fixed-point lookup tables (rsqrt, reciprocal, exp, sigmoid). It bisects only where the real fixed-point error is high, guaranteeing 2 LSB worst-case error with 12–30 tables per operator instead of 126.

Method & details →

12checkpoints, camera to on-board

Layered numerical consistency and release gates

QCraft · 2024–2026

Every stage from vehicle data to on-board post-processing is compared with the one before on identical inputs, so a mismatch has exactly one possible source. Results carry an evidence grade, and past failures re-run before every release.

Method & details →

7versioned contracts, 10 gates

A quantization-deployment platform (design draft)

QCraft · Nov 2026 onward

The target architecture: the fixed-point model as the single source of truth, versioned contracts between training, conversion and the vehicle, a blocking gate at every hop, and mixed precision planned from sensitivity and on-board latency cost. With the gate design and the migration approach.

Method & details →

0.7%prediction error on board

Predicting on-board latency before writing code

QCraft · 2025–2026

A block-level latency model predicted 19.38 ms against 19.25 ms measured. It ruled out a wider occupancy range at 10 Hz early, ranked six deployment options, and led to a backbone shared by five perception models.

Method & details →

5 → 1image encoders, est. 5–9 ms saved per frame

OneModel: five perception tasks on one shared vision encoder

QCraft · 2026 · in progress

The backbone is sized by a PCA redundancy analysis of released models and its pretraining weights are synthesized with a closed-form linear solve. Also covers how multi-task training is organized, and an end-to-end driving model design (proposal) one step further.

Method & details →

4,273production conversions

QNN Web, one-click model conversion for every chip

QCraft · 2022–2026

A conversion service: upload a model once and get engines for every target chip. Configs are generated from the graph, a TensorRT timing cache cut builds to about 5 minutes, and an MCP layer lets AI agents submit and track jobs.

Method & details →

350TOPS target chip

Urban NOA on a new chip (AXERA M95)

QCraft · 2026

Technical lead for porting the urban NOA stack: staged bring-up from a 700-TOPS demo board to the M95, model adaptation and quantization, and clustered road-test issues. The v4 stack runs on test vehicles with no frame drops on key models.

Method & details →

AR navigation perception SDK

Tencent Maps · 2021–2022

A multi-stream parallel perception framework with automatic profiling for phones and car head units: road-scene detection, parking-slot detection and AR guidance. 12 features in four months, CPU under 70%, shipped on the JMC CX743 production vehicle.

Method & details →

NBT evaluation platform

NBT evaluation platform

Tencent Maps · 2021–2022

Internal web platform for model and data management, evaluation runs, result tracking and data sharing, with interfaces for bad-case analysis, returned-data management and map-building visualization.

Method & details →

Patent, Talks & Engagement

Skills

Quantization
PTQ, QAT, QAD and distillation, LSQ / AutoQuant, AdaRound, scale search, mixed INT8/INT16, LUT-based non-linear operators, sensitivity analysis, per-layer error attribution
Deployment
Horizon J5 / J6M / J6P (Horizon plugin, HBIR/HBM, BPU), NVIDIA Orin (TensorRT, custom plugins, QDQ), Qualcomm (QNN), AXERA M95 / M97, TNN, MNN
Models
BEV detection, occupancy, vector maps, sparse temporal detection and tracking, end-to-end planning, multi-task perception, VLM
Training
PyTorch 1.x / 2.x, DDP, AMP / BF16, multi-node training on NVIDIA V100 / H20 and Alibaba PPU
Engineering
Python, C++, ONNX, TorchScript / LibTorch, gRPC services, Flask, MCP tool servers, AI coding agents, Git, CMake
Languages
Chinese (native), English (technical presentations and documentation)

Education

Beihang University (BUAA) 北京航空航天大学
M.Eng., Pattern Recognition
Sep 2016 – Jan 2019
Beihang University (BUAA) 北京航空航天大学
B.Eng., Automation
Sep 2012 – Jul 2016

Writing

All posts →

Last updated November 2026