Amazon: Applied Scientist (2025)

import numpy as np

class LogReg:
    def __init__(self, lr=0.1, epochs=1000, l2=0.0):
        self.lr, self.epochs, self.l2 = lr, epochs, l2
    def fit(self, X, y):
        n, d = X.shape
        self.w, self.b = np.zeros(d), 0.0
        for _ in range(self.epochs):
            p = 1 / (1 + np.exp(-(X @ self.w + self.b)))
            gw = X.T @ (p - y) / n + self.l2 * self.w
            gb = np.mean(p - y)
            self.w -= self.lr * gw; self.b -= self.lr * gb
        return self
    def predict_proba(self, X):
        return 1 / (1 + np.exp(-(X @ self.w + self.b)))
    def predict(self, X, t=0.5):
        return (self.predict_proba(X) >= t).astype(int)

• Explain the log-loss gradient Xᵀ(p − y)/n, why features should be standardised, L2 regularisation, and numerical stability (clip the logits).

import heapq

class MedianFinder:
    def __init__(self):
        self.lo, self.hi = [], []          # max-heap (negated), min-heap
    def add(self, x):
        heapq.heappush(self.lo, -x)
        heapq.heappush(self.hi, -heapq.heappop(self.lo))
        if len(self.hi) > len(self.lo):
            heapq.heappush(self.lo, -heapq.heappop(self.hi))
    def median(self):
        if len(self.lo) > len(self.hi): return -self.lo[0]
        return (-self.lo[0] + self.hi[0]) / 2

• Two heaps keep the lower half and the upper half: insert is O(log n) and reading the median is O(1).
• Follow-ups: a fixed window means lazy deletion; a bounded integer range means a counting array.

• Goal: a short "customers say..." summary plus pros and cons per product, kept fresh as reviews arrive.
• Pipeline: 1. Filter spam and very short reviews. 2. Aspect extraction: an LLM or fine-tuned model tags aspects (battery, fit, delivery) with sentiment. 3. Aggregate: count aspects, weighted by helpfulness and recency. 4. Summarise: an LLM writes a grounded summary from the top aspects and representative quotes.
• Scale: batch processing for millions of products; incremental updates when there are more than N new reviews; a smaller model for extraction and a larger one for the final text.
• Evaluation:
• Faithfulness: every claim must be supported by reviews.
• Coverage of the top aspects.
• Human ratings.
• Online A/B on conversion and returns.
• Risks: hallucination, fake-review manipulation, and bias towards early reviews. Use guardrails and periodic audits.

• Bias: error from wrong assumptions. The model is too simple (linear on non-linear data) and underfits.
• Variance: error from sensitivity to the training sample. The model is too complex (a deep tree) and overfits.
• Expected error = bias² + variance + irreducible noise.
• Levers:
• More data reduces variance.
• Regularisation and bagging (random forests) reduce variance.
• Boosting and richer features reduce bias.
• Diagnose with learning curves: if both errors are high, it's bias; if the gap is large, it's variance.

• Pre-training: next-token prediction on trillions of tokens of web, code and book text.
• Decoder-only Transformer with AdamW and warm-up plus cosine schedule.
• Mixed precision (bf16).
• Data, tensor and pipeline parallelism.
• Scaling laws (Chinchilla) guide the balance of model size and tokens.
• Mid-training / continued pre-training on domain or long-context data.
• Post-training:
• SFT on instruction data.
• Preference optimisation (RLHF with PPO, or DPO).
• RL with verifiable rewards for reasoning (maths and code).
• Safety tuning.
• Evaluation across benchmarks plus red-teaming. Watch for contamination and reward hacking.

Answer (STAR, about 2 minutes):

• Situation: "My manager wanted to launch the LLM classifier to all customers within two weeks."
• Task: I believed precision on minority categories was too low.
• Action: "I shared an error analysis: 18% false positives on refund requests. I proposed a two-week staged launch to 10% of traffic with human review. We agreed on the metrics up front."
• Result: "The staged launch caught a labelling bug. The full launch went a week later with 94% precision. My manager adopted staged launches as the default."
• Use data, keep it respectful, and show that you committed once the decision was made.

• Pick a story where you went beyond the dashboards. Example: "The model's AUC dropped 4 points in one region. I traced it to a change in an upstream feature pipeline: a currency field switched from INR to USD without notice."
• Explain the mechanisms you added: a data contract, a schema check, alerts on shifts in feature distributions.
• Quantify the impact: "We prevented about ₹X of mis-scored applications."

1. Problem and why it matters (3 minutes): business impact.
2. Your approach (15 minutes): data, model choices and why, the alternatives you rejected.
3. Results (7 minutes): offline and online metrics, ablations, failure cases.
4. What you would do next (3 minutes), then questions. - Be precise about your own contribution. Expect "why not X?" probes, and prepare backup slides with maths details.