Meta: Machine Learning Engineer

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cap, self.d = capacity, OrderedDict()
    def get(self, key):
        if key not in self.d: return -1
        self.d.move_to_end(key); return self.d[key]
    def put(self, key, value):
        if key in self.d: self.d.move_to_end(key)
        self.d[key] = value
        if len(self.d) > self.cap: self.d.popitem(last=False)

• Mention the classic version: a hash map + doubly-linked list (move a node to the head on access, evict the tail), which interviewers may ask you to write without OrderedDict.

• Goal: maximise long-term meaningful engagement (not just clicks), with integrity constraints.
• Stages: 1. Candidate generation: recent posts from friends, groups and pages plus recommended content (two-tower embeddings, ANN), giving thousands of candidates. 2. Light ranker: a cheap model trims to hundreds. 3. Heavy ranker: a multi-task deep model (DLRM-style) predicts P(like), P(comment), P(share), P(hide/report) and dwell time, combined with a value function of weighted predictions. 4. Re-ranking: diversity, freshness, creator fairness, integrity filters, ad insertion.
• Features: user–author affinity, content embeddings, recency, engagement velocity, context (device, time).
• Training: logged impressions; handle position bias; daily or online updates.
• Evaluation: offline NDCG and AUC per task → online A/B on engagement and guardrails (reports, time well spent).
• Serving and scale: feature store, caching, under 200 ms end to end; monitor drift and feedback loops.

Answer (show operational ownership):

• Data: scheduled ingestion with data-quality checks (schema, nulls, distributions) and alerts.
• Training: automated weekly retraining, experiment tracking, and an evaluation gate against the current model.
• Deployment: model registry, canary release, rollback.
• Monitoring: feature drift (PSI), prediction drift, latency, business KPIs, and label-delayed performance tracking.
• Incidents: "An upstream logging change broke a feature. Our drift alert fired, we rolled back within an hour, and we added a data contract."
• Interviewers want evidence that you owned it after launch, not just trained a notebook model.

from collections import Counter
import heapq

def top_k(nums, k):
    return [x for x, _ in heapq.nlargest(k, Counter(nums).items(), key=lambda t: t[1])]

• O(n log k) with a heap. Bucket sort by frequency gives O(n). Discuss ties and streaming variants (Count-Min Sketch).

• Users click higher positions more regardless of relevance, so naïve training learns "position = relevance".
• Fixes:
• Add position as a feature during training, and set it to a constant at serving.
• Inverse propensity weighting using estimated examination probabilities (from randomisation or result swaps).
• Click models such as cascade or DBN.
• Small exploration traffic to collect less-biased data.

Answer (STAR):

• Situation: "Our model's online gains disappeared after launch; nobody owned the logging pipeline."
• Action: "I traced it to a mismatch between training and serving features, wrote a parity test, and set up a weekly cross-team review with the data platform team."
• Result: "We recovered the +2.1% engagement lift, and the parity test caught two later issues before launch."
• Meta values move fast with ownership and impact backed by metrics.