SHAPLEY VALUE — INTUITION
Channels: {Social, Email, Search}. Consider all orderings and each channel's marginal contribution.
… (all 6 orderings) …
Shapley value = average marginal contribution across all orderings
This ensures "fair" credit that satisfies mathematical properties like:
- Efficiency: Total credit sums to 100%
- Symmetry: Equal contributors get equal credit
- Null player: Non-contributors get zero
- Additivity: Combines properly across games
### The Computational Problem
Shapley value requires calculating all permutations. With n channels, there are n! orderings:
| Channels | Orderings | Computation |
|----------|-----------|-------------|
| 3 | 6 | Trivial |
| 5 | 120 | Fast |
| 10 | 3,628,800 | Slow |
| 15 | 1,307,674,368,000 | Impossible |
For real-world channel counts, approximation algorithms (sampling) are necessary.
### Implementation Sketch
```ruby
class ShapleyValueAttribution
def initialize(channel_contributions)
# channel_contributions: Hash mapping channel combinations to conversion lift
# e.g., { [:social] => 0.10, [:social, :email] => 0.22, ... }
@contributions = channel_contributions
@channels = channel_contributions.keys.flatten.uniq
end
def calculate_shapley_values
@channels.map do |channel|
shapley = 0.0
# For each possible coalition not containing the channel
coalitions_without_channel = all_coalitions.reject { |c| c.include?(channel) }
coalitions_without_channel.each do |coalition|
coalition_with = (coalition + [channel]).sort
marginal = (@contributions[coalition_with] || 0) - (@contributions[coalition] || 0)
# Weight by coalition size
weight = factorial(coalition.size) * factorial(@channels.size - coalition.size - 1) /
factorial(@channels.size).to_f
shapley += weight * marginal
end
[channel, shapley]
end.to_h
end
private
def all_coalitions
(0..@channels.size).flat_map { |n| @channels.combination(n).to_a }
end
def factorial(n)
return 1 if n <= 1
n * factorial(n - 1)
end
end
```
### Shapley Pros and Cons
**Pros:**
- Mathematically "fair" distribution
- No inherent bias toward any position
- Theoretically sound (Nobel Prize-winning concept)
**Cons:**
- Computationally expensive (O(2^n))
- Requires high data volume (5,000+ conversions)
- Black box to non-technical stakeholders
- Hard to explain "what is a Shapley value?"
> **Warning:**
> **The Shapley paradox:** It's the most theoretically fair model, but also the hardest to explain. If stakeholders don't trust what they can't understand, Shapley's elegance doesn't help.
## How does machine learning attribution work?
### How It Works
ML-based attribution trains a model to predict conversion, then interprets which features (touchpoints) drove the prediction.
Common approaches:
| Method | How It Works | Interpretation |
|--------|--------------|----------------|
| **Logistic Regression** | Linear model with channel coefficients | Coefficients = importance |
| **Random Forest** | Ensemble of decision trees | Feature importance scores |
| **Gradient Boosting** | Sequential tree boosting | SHAP values for explanation |
| **Neural Networks** | Deep learning | Attention weights, SHAP |
### Example: Logistic Regression
```ruby
# Simplified example using channel presence as features
class MLAttribution
def initialize(journeys)
@journeys = journeys
@channels = extract_unique_channels(journeys)
end
def train_and_attribute
# Create feature matrix: each row = journey, columns = channel presence
x = @journeys.map { |j| @channels.map { |c| j[:touches].include?(c) ? 1 : 0 } }
y = @journeys.map { |j| j[:converted] ? 1 : 0 }
# Train logistic regression (pseudocode)
model = LogisticRegression.fit(x, y)
# Extract coefficients as channel importance
@channels.zip(model.coefficients).to_h
end
end
```
### SHAP Values for Model Interpretation
SHAP (SHapley Additive exPlanations) applies Shapley logic to ML models: