Qualcomm Autonomous Driving Chip Algorithm Interview: Model Quantization, Deployment Optimization, and Edge Inference

Background

I have a bachelor's in Automation and a master's focused on Computer Vision. After graduation, I spent 2 years as a model deployment engineer at an autonomous driving company, primarily working on model quantization, distillation, and edge-side deployment using chips including Horizon Robotics' BPU and NVIDIA Orin. Horizon is the absolute leader in autonomous driving chips, so when I saw they were hiring algorithm engineers, I applied right away.

Honestly, I hesitated before applying because Horizon's algorithm requirements are much higher than pure deployment roles, and my strengths lie more in engineering implementation. But on second thought, model deployment and algorithms are inseparable, and I had hands-on experience with quantization and inference optimization. About 10 days later, HR contacted me to schedule three technical rounds.

Interview Process Review

Round 1: Deep Learning Fundamentals + Quantization Principles (~1 hour)

Round 1 was with a young algorithm engineer who looked fairly new but asked sharp questions. After a self-introduction, we got started.

Deep Learning Fundamentals:

The first question caught me off guard — "Explain the principle of BatchNorm, and how does BN behave differently during training and inference?" I handled this reasonably well: during training, mini-batch mean and variance are used; during inference, running mean and running var are used. The interviewer followed up with "How is the running mean updated?" I explained the momentum parameter and exponential moving average.

Then activation functions — "What's the difference between ReLU and GELU? Why do Transformers use GELU instead of ReLU?" I explained that GELU is a smooth variant of ReLU with a smooth transition around zero, which is friendlier for gradient flow. Transformers use GELU because it performs better experimentally, especially on large models. The interviewer followed up with "What about SwiGLU?" I didn't know much about this, only mentioning it's a GLU variant using SiLU activation.

Next came attention mechanisms — "Explain the computation process of Multi-Head Attention. How are QKV obtained?" I walked through linear projection to get QKV, then scaled dot-product attention, and finally concatenation and linear transformation. The interviewer asked "Why divide by sqrt(d_k)?" I explained it prevents large dot-product values from causing softmax gradient vanishing.

Loss functions came up — "What's the relationship between cross-entropy loss and KL divergence? What problem does Focal Loss solve?" I said cross-entropy can be viewed as a special case of KL divergence, and Focal Loss addresses class imbalance by reducing the weight of easy samples.

Quantization Principles:

The first quantization question was "What's the basic principle of quantization? What's the difference between uniform and non-uniform quantization?" I explained that quantization maps floating-point numbers to low-bit integers, uniform quantization uses equal spacing, and non-uniform quantization can use unequal spacing. The interviewer followed up with "What's the difference between symmetric and asymmetric quantization? What are their pros and cons?" I said symmetric quantization has a zero point of 0 and simpler computation; asymmetric quantization has a zero point that can better utilize the quantization range.

Then the specific INT8 quantization process — "What's the difference between PTQ and QAT? What are their respective use cases?" I explained that PTQ doesn't require retraining, is faster but may have accuracy loss; QAT simulates quantization during training, has better accuracy but higher cost. The interviewer followed up with "How do you choose calibration data for PTQ? What calibration methods exist?"

They also asked about per-channel vs. per-tensor quantization and why per-channel works better. I explained that per-channel has independent scale and zero point for each channel, better adapting to value distribution differences across channels.

At the end of Round 1, the interviewer said "fundamentals are decent, quantization part was well answered," and told me to wait for Round 2.

Round 2: Model Deployment + TensorRT (~1.5 hours)

Round 2 was with a senior engineer, and questions were more practice-oriented.

It opened with a practical question — "Tell me about the most complex model deployment project you've done." I chose a BEV perception model deployment, from exporting the PyTorch model to ONNX, then converting to TensorRT engine, encountering various operator compatibility issues along the way. The interviewer followed up with "What specific operator incompatibilities did you encounter? How did you resolve them?" I described the custom plugin development process.

Then TensorRT optimization — "What optimizations does TensorRT perform? Why is inference so much faster?" I listed layer fusion, precision calibration, automatic kernel selection, and dynamic shape optimization. The interviewer specifically probed layer fusion — "Which layers can be fused? What are the fusion rules?"

Next came dynamic shapes — "How does TensorRT handle dynamic shapes? What's the performance impact?" I explained the use of optimization profiles and kernel selection strategies under dynamic shapes.

Model compression came up — "What's the principle of knowledge distillation? What distillation methods have you used?" I discussed the difference between logits distillation and feature distillation.

Round 2 also included a performance optimization question — "If your model's inference speed on BPU doesn't meet requirements, how would you analyze and optimize?" I said to first use profiling tools to identify bottlenecks — compute-bound or memory-bound — then optimize accordingly.

At the end of Round 2, the interviewer said "good engineering experience, but algorithm depth needs strengthening," which aligned with my self-assessment.

Round 3: Edge Inference + Project Deep Dive (~1.5 hours)

Round 3 was with the department's technical lead, focusing more on system-level thinking.

First, they asked me to detail Horizon BPU's architecture characteristics. I was well-prepared for this, starting from BPU's Bernoulli architecture, covering the BNN acceleration engine, high-precision floating-point support, and flexible storage architecture. The interviewer followed up with "What are the main differences between BPU and GPU in inference scenarios?" I said BPU is specifically designed for deep learning inference with higher energy efficiency; GPUs are more general-purpose but consume more power.

Then edge inference challenges — "What's the biggest difference between edge and cloud inference? What special constraints does edge have?" I listed compute limitations, memory constraints, power constraints, and real-time requirements. The interviewer followed up with "How do you trade off between accuracy and speed?"

Multi-task models came up — "In autonomous driving scenarios, how do perception, prediction, and planning tasks run efficiently on one chip?" I discussed model sharing, task scheduling, and memory management strategies.

Finally, several open-ended questions — "What's your take on the edge large model trend?" and "What's the direction for autonomous driving chips in the next 3 years?" I shared my views based on industry trends.

About 5 days after Round 3, HR notified me that I passed. Overall, Horizon's interviews heavily emphasize practical experience — pure theory questions are rare.

Key Questions Summary

Deep Learning Fundamentals:

1. BatchNorm principles and behavioral differences between training and inference

2. Differences between ReLU, GELU, and SwiGLU

3. Multi-Head Attention computation process

4. Why divide by sqrt(d_k)

5. Relationship between cross-entropy and KL divergence

6. Focal Loss principles

Quantization:

7. Differences between uniform and non-uniform quantization

8. Pros and cons of symmetric vs. asymmetric quantization

9. PTQ vs. QAT differences and use cases

10. Calibration data selection and calibration methods

11. Per-channel vs. per-tensor quantization differences

Model Deployment:

12. ONNX model export and operator compatibility issues

13. TensorRT custom plugin development

14. TensorRT optimization strategies

15. Layer fusion rules and conditions

16. Dynamic shape handling methods

17. Knowledge distillation principles and methods

Edge Inference:

18. BPU architecture characteristics and GPU differences

19. Special constraints of edge inference

20. Multi-task model resource allocation

21. Accuracy vs. speed trade-off strategies

Key Takeaways

1. Quantization knowledge is a core competitive advantage. Horizon's interviews have high quantization requirements — knowing concepts isn't enough; you need to explain specific calibration processes, accuracy evaluation methods, and applicable scenarios for different quantization strategies. I recommend completing at least one full INT8 quantization project.

2. Be able to articulate deployment experience in detail. Interviewers will probe specific problems encountered during deployment — which operator was incompatible, how you resolved it, how much performance improved. These details can't be fabricated; you need real experience.

3. Understand the target chip's architecture. Horizon's interview will definitely ask about BPU-related knowledge. Knowing nothing about BPU architecture will significantly hurt your chances. I recommend studying Horizon's public technical documentation beforehand.

4. Algorithm fundamentals shouldn't be too weak. Although model deployment roles lean toward engineering, Horizon also has algorithm requirements. You should understand deep learning basics, common model architectures, and training techniques.

5. Stay current with the autonomous driving industry. Interviewers will ask industry-related questions. Having your own understanding of autonomous driving technology trends will earn bonus points.

FAQ

Q: Does Horizon require strong algorithm skills?

A: Higher than pure deployment roles, but they won't ask you to design models from scratch. They care more about your depth of model understanding and deployment optimization capabilities.

Q: Can you pass without autonomous driving experience?

A: Model deployment experience is sufficient; autonomous driving background isn't required. But the interview will include some autonomous driving scenario questions, so I recommend familiarizing yourself beforehand.

Q: Do they ask you to write code on the spot?

A: Yes. Round 1 had me hand-write quantization calibration pseudocode; Round 2 required writing a basic TensorRT plugin framework.

Q: What's the work intensity like?

A: Horizon's work intensity is above average in the chip industry. Overtime happens during tight project phases, but the overall pace is manageable.

Q: How's the compensation?

A: Horizon's compensation is at the top level in the autonomous driving chip industry. With stock options, the overall package is very competitive.