Netflix Business Model, Revenue & Cost Structure Questions

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.calibration import CalibratedClassifierCV
from sklearn.base import clone
from sklearn.utils.validation import check_is_fitted

def train_two_model_uplift(X, treatment, y,
                           model=LogisticRegression(solver="lbfgs", max_iter=1000),
                           calibrate=True,
                           calibrator_method='sigmoid',
                           random_state=None):
    """
    X: pandas DataFrame or numpy array of features
    treatment: array-like (0/1)
    y: array-like binary outcome (0/1)
    model: base classifier (must implement fit, predict_proba)
    calibrate: whether to wrap with CalibratedClassifierCV
    calibrator_method: 'sigmoid' or 'isotonic'
    Returns: score_uplift(X_new) -> numpy array of uplift scores
    """
    X = pd.DataFrame(X) if not isinstance(X, (pd.DataFrame, pd.Series)) else X.copy()
    treatment = np.asarray(treatment)
    y = np.asarray(y)

    # Split treated / control
    mask_t = treatment == 1
    mask_c = treatment == 0

    if mask_t.sum() == 0 or mask_c.sum() == 0:
        raise ValueError("Both treatment and control groups must be present.")

    # Fit models separately
    model_t = clone(model)
    model_c = clone(model)

    if calibrate:
        model_t = CalibratedClassifierCV(base_estimator=model_t, cv=3, method=calibrator_method)
        model_c = CalibratedClassifierCV(base_estimator=model_c, cv=3, method=calibrator_method)

    model_t.fit(X.loc[mask_t, :], y[mask_t])
    model_c.fit(X.loc[mask_c, :], y[mask_c])

    def score_uplift(X_new):
        X_new = pd.DataFrame(X_new) if not isinstance(X_new, (pd.DataFrame, pd.Series)) else X_new
        # verify fitted
        try:
            check_is_fitted(model_t)
            check_is_fitted(model_c)
        except Exception:
            pass  # CalibratedClassifierCV may not expose usual attributes; rely on predict_proba

        # predict_proba -> probability of class 1
        p_t = model_t.predict_proba(X_new)[:, 1]
        p_c = model_c.predict_proba(X_new)[:, 1]
        return p_t - p_c

    return score_uplift