TikTok interview questions

The candidate item is the query; the user's behaviour sequence supplies the keys and values. Each past item is embedded from its ID, category and context like time gap, then projected into a key and a value; the candidate's embedding is projected to the query.

Softmax over query-key scores weights the history, so the output is a candidate-specific interest vector, the target attention DIN introduced. Cost grows with history length per candidate, so long histories are truncated or filtered first.

State shapes as you go: x is T by d, scores T by T. Mask before the softmax, and normalise stably.

def attention(x, Wq, Wk, Wv, mask):   # x: (T, d)
    q, k, v = x @ Wq, x @ Wk, x @ Wv  # (T, d_k), (T, d_v)
    s = q @ k.T / np.sqrt(k.shape[-1])  # (T, T)
    s = np.where(mask, s, -1e9)       # mask: True = keep
    s = s - s.max(-1, keepdims=True)
    p = np.exp(s)
    p /= p.sum(-1, keepdims=True)
    return p @ v                      # (T, d_v)

def cross_entropy(logits, y, ignore=-100):  # (N, V), (N,)
    keep = y != ignore
    z, t = logits[keep], y[keep]
    m = z.max(-1, keepdims=True)
    lse = m[:, 0] + np.log(np.exp(z - m).sum(-1))
    return (lse - z[np.arange(len(t)), t]).mean()

Cross-entropy is log-sum-exp minus the target logit, averaged over non-ignored tokens. Interviewers check the scale by the key width, masking scores rather than zeroing probabilities, and that padding labels are skipped.

FlashAttention computes exact attention in tiles kept in on-chip SRAM, with an online softmax, so the full score matrix never goes to HBM. Memory becomes linear in length, and it's faster because attention is memory-bound.

The KV cache keeps past keys and values so each decode step computes only the new token, trading memory for compute. RoPE rotates queries and keys by position-dependent angles, so dot products depend on relative position, parameter-free.

AUC is the chance a random positive outscores a random negative, so compute it from average ranks, which counts ties as half.

def auc(y, s):
    order = np.argsort(s, kind="mergesort")
    ss = s[order]
    ranks = np.empty(len(s))
    i = 0
    while i < len(s):          # average rank per tie group
        j = i
        while j + 1 < len(s) and ss[j + 1] == ss[i]:
            j += 1
        ranks[order[i:j + 1]] = (i + j) / 2 + 1
        i = j + 1
    pos = y == 1
    n_pos, n_neg = pos.sum(), (~pos).sum()
    u = ranks[pos].sum() - n_pos * (n_pos + 1) / 2
    return u / (n_pos * n_neg)

def softmax(z):
    z = z - z.max(axis=-1, keepdims=True)
    e = np.exp(z)
    return e / e.sum(axis=-1, keepdims=True)

def fit_logreg(X, y, lam=0.1, lr=0.1, steps=2000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(steps):
        z = X @ w + b
        p = 0.5 * (1 + np.tanh(z / 2))   # stable sigmoid
        g = p - y
        w -= lr * (X.T @ g / len(y) + lam * w)  # no L2 on b
        b -= lr * g.mean()
    return w, b

Interviewers check ties, overflow on large logits, which subtracting the max prevents, and that the bias isn't regularised.

PPO-based RLHF trains a reward model, then samples and maximises reward with a KL penalty. DPO solves that objective in closed form, training on preference pairs with a classification-style loss: raise the chosen answer's log-ratio over the rejected one, relative to the reference. No reward model or sampling loop.

Data: per prompt, sample several responses from the SFT model itself; humans or a validated judge pick chosen and rejected. Drop ties, watch length bias.

Policies are deterministic or stochastic, on- or off-policy. Policy gradients raise the log-probability of high-advantage actions. TRPO bounds each update with a KL trust region; PPO gets similar stability from a cheap clipped ratio. GAE weights TD errors exponentially, with lambda trading bias for variance.

Linear attention swaps softmax for a kernel map: linear cost, usually lower quality. GQA keeps exact attention and shares key-value heads across query groups, shrinking the KV cache.

Use LLMs where they add knowledge ID models lack, off the hot path.

Offline enrichment: generate tags, summaries and embeddings from titles, descriptions and frames. That mostly helps cold start, since a new item has meaningful features before it has clicks. Generative retrieval: give items semantic IDs, codes from quantized content embeddings, and train a sequence model to generate the next item's ID, as in TIGER. Semantic reranking: a distilled LLM rescores the top few dozen candidates against the user's intent. Judge each by offline recall and NDCG, then A/B tests.

Predict the marginal value of more candidates per request. Label offline by replaying traffic at several K values and recording where the final ranker's top results stop changing.

Features: user activity, history length, request context and current load. A small model, say gradient-boosted trees, picks K from a few buckets to maximise value minus latency and compute cost, with a safe floor. A/B test against fixed K, watching p99 latency.

Two encoders, image and text, project into one shared space. Train on pairs with a contrastive InfoNCE loss, as CLIP does: each image must outscore the batch with its own caption, so big batches and hard negatives matter.

Evaluate with retrieval recall at k both ways and zero-shot classification. To deploy, index item embeddings for ANN search and encode queries online. Version the index with the model: embeddings from two versions aren't comparable.

Cut work before cutting the model. Sample a few keyframes instead of every frame, and drop near-duplicates. Use a smaller or quantized model, cap length, and batch requests to keep the GPU busy. Captions rarely need to be instant, so use an async queue and cache per video. Check quality on held-out videos.