Why heuristics fail, and the data-driven leap

Heuristics assert credit; they never learn it. Once you have coded all six (Session 2), the cracks are obvious and they come in three shapes. Naming them precisely is what makes the data-driven model feel inevitable rather than fancy.

• No interactions. A heuristic scores each touch in isolation. It cannot express "paid_social is only valuable when email follows it." Real journeys are full of these lifts, and a fixed rule is structurally blind to every one.
• Path-blind weighting. The value a heuristic assigns a channel does not depend on the rest of the path. Display gets 40% under position-based whether it opened a winning journey or a dead one - the weight is a constant, not a response to the data.
• Arbitrary weights. Why 40/40/20 and not 30/30/40? Why a 7-day half-life? Nobody can defend the constants because they were never estimated - they were chosen. The numbers look precise and are entirely made up.

In 2011 Shao and Li published the paper that launched data-driven multi-touch attribution. The move is simple and profound: stop assigning credit by rule, and instead predict whether a journey converts from the set of channels it contains. Fit a model, and the per-channel weights it learns are the attribution. Credit becomes something estimated from data, not decreed.

There is a catch Shao and Li had to solve. Marketing channels are heavily correlated - customers who see paid_social often also get email, journeys that hit organic often hit paid_search. Feed correlated dummy variables to a plain logistic regression and the coefficients thrash: tiny changes in the sample flip a channel's weight from strongly positive to negative. Attribution you cannot reproduce is attribution you cannot defend.

Crossing from heuristics to data-driven is a real upgrade - credit now responds to the data - but it is not a leap to causality. Hold two truths at once so you never oversell the result upstairs.

First turn Lumen's path table into the Shao-Li feature matrix: one row per journey, one 0/1 column per channel, and a converted label. This is the input every data-driven model in the course reuses.

import pandas as pd

CHANNELS = ["paid_search","paid_social","display","organic_search",
            "email","affiliate","influencer","ctv","direct"]

tp = pd.read_parquet("lumen_fct_touchpoints.parquet")

# one row per customer, 1 if the channel appears anywhere in the journey
X = (tp.assign(flag=1)
       .pivot_table(index="customer_id", columns="channel",
                    values="flag", aggfunc="max", fill_value=0)
       .reindex(columns=CHANNELS, fill_value=0))

# label: did this journey convert? (include non-converting journeys too!)
conv = pd.read_parquet("lumen_conversions.parquet")
y = X.index.isin(conv["customer_id"]).astype(int)

print(X.shape, y.mean().round(3))   # feature matrix + base conversion rate

Now the Shao-Li model itself. Wrap LogisticRegression in scikit-learn's BaggingClassifier, sampling both rows and features, then average the base estimators' coefficients into stable per-channel credit.

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import BaggingClassifier

bag = BaggingClassifier(
    estimator=LogisticRegression(max_iter=1000),
    n_estimators=200,
    max_samples=0.8,      # bootstrap the journeys (rows)
    max_features=0.6,     # sample the channels (features) - the Shao-Li twist
    bootstrap=True,
    random_state=42,
).fit(X.values, y)

# average each channel's coefficient across the base learners that used it
coef_sum = np.zeros(X.shape[1]); coef_cnt = np.zeros(X.shape[1])
for est, feats in zip(bag.estimators_, bag.estimators_features_):
    coef_sum[feats] += est.coef_[0]
    coef_cnt[feats] += 1
avg_coef = coef_sum / np.maximum(coef_cnt, 1)

credit = pd.Series(avg_coef, index=X.columns).sort_values(ascending=False)
# turn positive coefficients into a % credit split
credit_share = (credit.clip(lower=0) / credit.clip(lower=0).sum() * 100).round(1)
print(credit_share)

The moment it pays off: line the learned credit up against the last-touch rollup from Session 2 and see exactly which channels last-touch was starving.

# last_touch_share from B2's channel rollup (% of credit)
compare = pd.DataFrame({
    "last_touch":  last_touch_share,
    "data_driven": credit_share,
}).fillna(0)
compare["delta"] = (compare["data_driven"] - compare["last_touch"]).round(1)
print(compare.sort_values("delta", ascending=False))

# Expect: paid_social / email / display GAIN credit (they create demand);
# paid_search LOSES the inflated last-touch share it never earned alone.

• Run all three build-alongs on Lumen and save the compare delta table - Session 4 (Markov) will add a third column to it.
• Demonstrate the instability yourself. Fit a plain logistic on 10 bootstrap resamples, plot each channel's coefficient across the runs, then do the same for the bagged model. The spread difference is the point of the whole session.
• Build the conditional-probability model. Compute P(conv | channel) and P(conv | channel pair) on Lumen and compare its ranking to the bagged-logistic ranking. Where do they disagree, and why?
• Optional: read Shao & Li (2011) sections 2-3. You have now implemented both models they propose - the paper reads like your own code.

This session builds the historical root of data-driven attribution directly from the founding paper, on Lumen data - the bridge no heuristics course crosses and the foundation Markov and Shapley extend.