Waymo interview questions

Assume 100 million users each send 10 requests a day: about 11,600 QPS average, peaks perhaps 2 to 3 times higher. Weights are parameters times bytes, so a 70B model in 16-bit is 140 GB, sharded across GPUs. KV cache per token is 2 times layers times KV heads times head dimension times bytes, times context and concurrency.

For tail latency: continuous batching, admission control, split prefill and decode, autoscale on queue depth.

Quantization-aware training simulates low-precision rounding during fine-tuning, so accuracy holds better than post-training quantization. Distillation trains a small student on a teacher's soft outputs. Eval mode disables dropout and makes batch norm use running statistics; forgetting it corrupts metrics. Contrastive learning pulls matching pairs together in embedding space and pushes others apart. Verify each on a fixed held-out set and the target hardware: accuracy per slice, latency and memory versus the baseline.

Layer it. Deterministic checks run on everything, LLM judges score the rest, and humans label a stratified sample plus cases where judges are unsure or disagree.

Humans are the reference. Each judge, meaning model, prompt and settings, is calibrated against a gold set and promoted only when its agreement with humans, by Cohen's kappa, nears the agreement between humans. Low inter-annotator agreement means the rubric is unclear. Re-validate judges on fresh labels regularly and whenever the judge or product changes, and report per slice with confidence intervals.

Accuracy hides rare events; compare counts on the same cases. If both models saw the same data, use McNemar's paired test, which uses only cases where they disagree. For rates like detections per thousand miles, compare Poisson rates with an exact test. With few events, report the wide intervals too.

import numpy as np

def kmeans(X, k, iters=100, seed=0):
    rng = np.random.default_rng(seed)
    C = X[rng.choice(len(X), k, replace=False)]
    for _ in range(iters):
        d = ((X[:, None] - C[None]) ** 2).sum(-1)
        a = d.argmin(1)
        new = np.array([X[a == j].mean(0)
                        if (a == j).any() else C[j]
                        for j in range(k)])
        if np.allclose(new, C):
            break
        C = new
    return C, a

It minimises the within-cluster sum of squared distances: assign points to the nearest centroid, move centroids to their means, repeat. It reaches a local optimum, so use k-means++ and restarts. For train-inference mismatch, reuse the training scaler and monitor distances to centroids; drift means refit.

import numpy as np

def softmax_ce(logits, y):
    z = logits - logits.max(1, keepdims=True)
    p = np.exp(z)
    p /= p.sum(1, keepdims=True)
    n = len(y)
    loss = -np.log(p[np.arange(n), y] + 1e-12).mean()
    grad = p.copy()
    grad[np.arange(n), y] -= 1
    return loss, grad / n

def train(X, y, k, lr=0.1, epochs=100):
    W = np.zeros((X.shape[1], k))
    b = np.zeros(k)
    for _ in range(epochs):
        loss, g = softmax_ce(X @ W + b, y)
        W -= lr * X.T @ g
        b -= lr * g.sum(0)
    return W, b

Subtract the row maximum before exponentiating, for numerical stability. The gradient with respect to the logits is probabilities minus the one-hot label, averaged over the batch; the chain rule gives X transposed times that for the weights. Interviewers look for the stability trick, the averaging, and a finite-difference gradient check.