Baseline Catalog

from sklearn.dummy import DummyClassifier
from sklearn.metrics import average_precision_score, log_loss, roc_auc_score

for strategy in ("most_frequent", "prior", "stratified"):
    d = DummyClassifier(strategy=strategy, random_state=0).fit(X_train, y_train)
    p = d.predict_proba(X_test)[:, 1]
    print(strategy, roc_auc_score(y_test, p), average_precision_score(y_test, p), log_loss(y_test, p, labels=[0, 1]))

rule = (X_test["support_calls"] >= 3) | (X_test["last_login_days"] > 30)
from sklearn.metrics import precision_score, recall_score
print("rule precision", precision_score(y_test, rule), "recall", recall_score(y_test, rule))

import pandas as pd
from sklearn.metrics import roc_auc_score

def one_feature_auc(col, bins=10):
    if pd.api.types.is_numeric_dtype(X_train[col]):
        edges = pd.qcut(X_train[col], bins, retbins=True, duplicates="drop")[1]
        tr = pd.cut(X_train[col], edges, include_lowest=True)
        te = pd.cut(X_test[col].clip(edges[0], edges[-1]), edges, include_lowest=True)
    else:
        tr, te = X_train[col], X_test[col]
    rate = y_train.groupby(tr, observed=True).mean()
    return roc_auc_score(y_test, te.map(rate).astype(float).fillna(y_train.mean()))

from sklearn.dummy import DummyRegressor
for strategy in ("mean", "median"):
    d = DummyRegressor(strategy=strategy).fit(X_train, y_train)

import numpy as np

def naive(y, h):                      # last observed value
    return np.repeat(y[-1], h)

def seasonal_naive(y, h, m):          # same point one season ago
    return np.array([y[-m + (i % m)] for i in range(h)])

def drift(y, h):                      # straight line from first to last value
    slope = (y[-1] - y[0]) / (len(y) - 1)
    return y[-1] + slope * np.arange(1, h + 1)

def moving_average(y, h, w=28):
    return np.repeat(np.mean(y[-w:]), h)

def mase(y_true, y_pred, y_train, m):
    scale = np.mean(np.abs(y_train[m:] - y_train[:-m]))
    return np.mean(np.abs(y_true - y_pred)) / scale

def croston(y, h, alpha=0.1, sba=True):
    z = p = None
    q = 1
    for v in y:
        if v > 0:
            z = v if z is None else z + alpha * (v - z)
            p = q if p is None else p + alpha * (q - p)
            q = 1
        else:
            q += 1
    if z is None:
        return np.zeros(h)
    f = z / p * ((1 - alpha / 2) if sba else 1)
    return np.repeat(f, h)

popular = train.groupby("item_id").size().sort_values(ascending=False).index[:10]
# per-user top-k excluding items already seen
def recommend(user, k=10):
    seen = set(train.loc[train.user_id == user, "item_id"])
    return [i for i in popular_full if i not in seen][:k]

med = X_train.median()
mad = (X_train - med).abs().median() * 1.4826
score = ((X_test - med).abs() / mad.replace(0, np.nan)).max(axis=1)   # worst robust z across features