Netflix Business Context & Data Engineering Role Questions

WITH recent AS (
  SELECT event_id, user_id, title_id, watch_seconds
  FROM playback_events
  WHERE ts >= date_sub(current_date(), 90)      -- push predicate early
    AND watch_seconds IS NOT NULL
)
SELECT c.genre,
       AVG(r.watch_seconds) AS avg_watch_seconds,
       COUNT(*) AS plays
FROM recent r
JOIN catalog c
  ON r.title_id = c.title_id
GROUP BY c.genre
ORDER BY avg_watch_seconds DESC
LIMIT 10;

import numpy as np

def ips_estimate(actions, propensities, rewards, target_propensities,
                 clip_min=0.0, clip_max=None, self_normalize=False, eps=1e-12):
    """
    Compute IPS estimate of expected reward under target policy.

    actions: array-like of shape (n,) with indices/labels of taken actions
    propensities: array-like shape (n,) logging policy prob of the taken action
    rewards: array-like shape (n,) observed rewards
    target_propensities: array-like shape (n,) target policy prob for the same action
    clip_min, clip_max: optional lower/upper bounds for importance weights
    self_normalize: if True, return self-normalized IPS (weighted mean)
    eps: numerical stability
    """
    actions = np.asarray(actions)
    p = np.asarray(propensities, dtype=float)
    q = np.asarray(target_propensities, dtype=float)
    r = np.asarray(rewards, dtype=float)
    if not (len(p)==len(q)==len(r)==len(actions)):
        raise ValueError("All inputs must have the same length")
    # Importance weights
    w = q / (p + eps)
    # Clipping
    if clip_min is not None:
        w = np.maximum(w, clip_min)
    if clip_max is not None:
        w = np.minimum(w, clip_max)
    if self_normalize:
        w_sum = np.sum(w)
        if w_sum <= eps:
            return 0.0
        return float(np.sum(w * r) / w_sum)
    else:
        return float(np.mean(w * r))