Data-Driven Attribution: Markov Chains, Shapley Values, and ML Models

class MarkovChainAttribution
  def initialize(conversions:, non_conversions:)
    @conversions = conversions        # Array of converting paths
    @non_conversions = non_conversions # Array of non-converting paths
    @channels = extract_unique_channels
  end

  def calculate_credit
    baseline_rate = conversion_rate(@conversions, @non_conversions)

    removal_effects = @channels.map do |channel|
      # Remove channel from all paths
      modified_conversions = remove_channel(@conversions, channel)
      modified_non_conversions = remove_channel(@non_conversions, channel)

      # Recalculate conversion rate
      modified_rate = conversion_rate(modified_conversions, modified_non_conversions)

      # Calculate removal effect
      effect = (baseline_rate - modified_rate) / baseline_rate
      [channel, effect.clamp(0, 1)]
    end.to_h

    # Normalize to sum to 1
    total_effect = removal_effects.values.sum
    removal_effects.transform_values { |v| v / total_effect }
  end

  private

  def conversion_rate(conversions, non_conversions)
    conversions.size.to_f / (conversions.size + non_conversions.size)
  end

  def remove_channel(paths, channel)
    paths.map { |path| path.reject { |c| c == channel } }
         .reject(&:empty?)
  end
end

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

# 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

# mbuzz AML - Markov Chain Attribution
model: markov_chain
name: "Markov Attribution"
description: "Calculate channel importance via removal effect"

settings:
  lookback_window: 30d
  order: 1                    # First-order Markov (previous state only)
  min_path_frequency: 10      # Ignore paths with < 10 occurrences
  include_non_conversions: true

validation:
  min_conversions: 2000       # Warn if below threshold
  holdout_percentage: 20      # Reserve for validation

model: shapley
name: "Shapley Attribution"
description: "Game-theoretic fair credit distribution"

settings:
  lookback_window: 30d
  sampling_iterations: 10000   # Approximate (full computation too slow)
  channel_limit: 15           # Max channels (complexity grows 2^n)

validation:
  min_conversions: 5000       # Higher threshold for Shapley
  convergence_threshold: 0.01 # Stop when values stabilize

model: ml_attribution
name: "ML Attribution"
algorithm: gradient_boosting   # Options: logistic, random_forest, gradient_boosting

settings:
  lookback_window: 30d
  features:
    - channel_sequence
    - time_between_touches
    - touchpoint_count
    - device_type
    - day_of_week

training:
  train_test_split: 0.8
  cross_validation_folds: 5
  retrain_frequency: weekly

interpretation:
  method: shap               # SHAP values for per-conversion explanation
  aggregate_to: channel

model: hybrid
name: "Adaptive Attribution"

primary:
  model: markov_chain
  settings:
    min_path_frequency: 10

fallback:
  model: linear              # Use linear when data insufficient
  trigger_when:
    monthly_conversions_below: 2000
    path_diversity_below: 0.3

notification:
  alert_on_fallback: true
  email: attribution-team@company.com

# Run multiple models to validate data-driven outputs
models:
  - model: markov_chain
    name: "Markov"
    settings:
      lookback_window: 30d

  - model: linear
    name: "Linear Baseline"
    settings:
      lookback_window: 30d

  - model: position_based
    name: "Position Baseline"
    settings:
      first_weight: 0.40
      last_weight: 0.40

comparison:
  enabled: true
  primary: "Markov"
  divergence_threshold: 0.25    # Alert if >25% difference from baselines
  report_frequency: weekly

# Early-stage: Don't use data-driven yet
# Stick to rule-based until you have volume

---

# Growth-stage: Start testing Markov
model: markov_chain
name: "Growth Markov"

settings:
  lookback_window: 30d
  min_path_frequency: 5       # Lower threshold (less data)

validation:
  min_conversions: 2000
  compare_to_baseline: linear

# Run in parallel with linear, don't use for decisions yet
mode: shadow

---

# Scale-stage: Full data-driven with validation
model: markov_chain
name: "Production Markov"

settings:
  lookback_window: 30d
  order: 1
  min_path_frequency: 20      # Higher threshold (more data)

validation:
  holdout_percentage: 20
  incrementality_tests:
    frequency: quarterly
    channels: [paid_social, display]

mode: production

# Black Friday / Holiday: Retrain more frequently
model: markov_chain
name: "Holiday Markov"

settings:
  lookback_window: 14d        # Shorter window, fresh patterns
  min_path_frequency: 5       # Lower threshold (paths are new)

training:
  retrain_frequency: daily    # Patterns changing rapidly
  warm_start: true            # Build on previous model

date_range:
  start: "2024-11-15"
  end: "2024-12-31"

# Compare to baseline to detect anomalies
comparison:
  baseline_model: "Standard Markov"
  alert_on_divergence: 0.30

# Major Campaign Launch: Isolate and train separately
model: markov_chain
name: "Launch Campaign Markov"

settings:
  lookback_window: 14d

filters:
  require_campaign:
    - "product-launch-2024"

# Separate model for launch to avoid contaminating main model
mode: isolated

# Compare launch paths to normal paths
comparison:
  baseline_model: "Production Markov"
  report_differences: true

# Use Markov for interpretability
model: markov_chain
name: "Explainable Attribution"
use_case: stakeholder_reporting

settings:
  order: 1
  output_removal_effects: true    # Show "what if" for each channel

---

# Use Shapley for fairness
model: shapley
name: "Fair Attribution"
use_case: cross_team_credit

settings:
  sampling_iterations: 10000

---

# Use ML for maximum accuracy (if you have the data)
model: ml_attribution
name: "Predictive Attribution"
use_case: budget_optimization

settings:
  algorithm: gradient_boosting
  features:
    - channel_sequence
    - touchpoint_timing
    - user_segment
  interpretation:
    method: shap

model: markov_chain
name: "Quality-Controlled Markov"

settings:
  lookback_window: 30d

data_quality:
  # Remove suspicious paths
  max_touchpoints_per_day: 50     # Cap unrealistic activity
  min_time_between_touches: 1s    # Remove duplicate clicks
  exclude_bot_traffic: true

  # Path deduplication
  dedupe_level: session
  dedupe_window: 30m              # Same channel within 30m = one touch

  # Identity resolution
  require_identity: false         # Include anonymous paths
  stitch_anonymous: true          # Connect anonymous → known

validation:
  path_diversity_min: 0.3         # Alert if paths too homogeneous
  channel_coverage_min: 0.8       # Alert if channels underrepresented

model: markov_chain
name: "Validated Markov"

validation:
  # Statistical validation
  holdout_percentage: 20
  cross_validation: true

  # Business validation
  compare_to_models:
    - linear
    - position_based
  divergence_alert_threshold: 0.25

  # Ground truth validation
  incrementality_tests:
    frequency: quarterly
    channels_to_test:
      - paid_social
      - display
      - email
    calibration:
      enabled: true
      apply_to_attribution: true

  # Stability monitoring
  weekly_stability_check: true
  alert_on_volatile_channels: true   # >30% swing week-over-week

reporting:
  include_confidence_intervals: true
  show_model_diagnostics: true