Your first real model, and the 96.8% that means nothing

You now have a clean, stratified split from b2. Time to train a real model on it and score it honestly. We will build a logistic regression classifier for converted, and in the same breath confront why its headline accuracy is a mirage. When only 3.2% of sessions convert, guessing "no" every single time is right 96.8% of the time - so any metric that rewards that behaviour is measuring the wrong thing. The whole point of today is to feel that gap on live numbers.

Despite the name, logistic regression is a classifier. It takes a linear combination of the features - a raw score - and squeezes it through the logistic (sigmoid) curve into a probability between 0 and 1. That probability is what predict_proba returns. predict then applies a threshold - 0.5 by default - to turn the probability into a yes/no. The threshold is a choice, not a law, and choosing it well is the b7 story.

proba = clf.predict_proba(X_te)[:, 1]     # P(convert) for each row
preds_default = (proba >= 0.5).astype(int)   # default - catches almost no one
preds_aggressive = (proba >= 0.10).astype(int) # lower bar - catches more buyers

We reload Lumen, reuse the stratified split from b2, scale the numeric features on train only, fit logistic regression, and read three numbers in order: accuracy (looks great), the dumb-baseline accuracy (identical - the paradox), and ROC-AUC (the honest signal). Precision and recall come in b7.

import numpy as np, pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

df = pd.read_parquet("lumen_sessions.parquet")

num_cols = ["prior_30d_spend", "pages_viewed", "session_hour"]
X = df[num_cols]
y = df["converted"]

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y)

scaler = StandardScaler().fit(X_tr)        # fit on TRAIN only
X_tr_s = scaler.transform(X_tr)
X_te_s = scaler.transform(X_te)

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

clf = LogisticRegression(max_iter=1000).fit(X_tr_s, y_tr)
preds = clf.predict(X_te_s)

print("accuracy: %.3f" % accuracy_score(y_te, preds))   # ~ 0.968

from sklearn.dummy import DummyClassifier

dumb = DummyClassifier(strategy="most_frequent").fit(X_tr_s, y_tr)
print("always-no accuracy: %.3f" % dumb.score(X_te_s, y_te))   # ~ 0.968

print("buyers our model flagged:", int(preds.sum()))   # very few - near zero
print("buyers in the test set  :", int(y_te.sum()))    # ~320

from sklearn.metrics import roc_auc_score

proba = clf.predict_proba(X_te_s)[:, 1]        # P(convert)
print("ROC-AUC: %.3f" % roc_auc_score(y_te, proba))   # ~ 0.71

• Look at the probabilities. Print a histogram of clf.predict_proba(X_te)[:, 1]. Notice how most mass sits well below 0.5 - that is why the 0.5 threshold catches so few buyers.
• Count the catches. How many actual buyers does the 0.5 threshold flag as "yes"? Compare to the ~320 buyers in the test set. Then lower the threshold to 0.10 and count again.
• Build the baseline yourself. Without DummyClassifier, compute the always-0 accuracy by hand: 1 - y_te.mean(). Confirm it lands at ~96.8% and matches the model. Write one sentence on why that equality is the whole lesson.

This builder session trains logistic regression end to end on Lumen and confronts the accuracy paradox with ROC-AUC. The full confusion matrix, precision, recall, F1, and threshold tuning get their own session in b7.