Introduction à la Modélisation Mixte Marketing (MMM)

L'évaluation précise de la performance des campagnes publicitaires est cruciale pour l'optimisation des budgets marketing. Les approches traditionnelles se heurtent souvent à des données éparses et à la complexité des interactions entre canaux. Meridian, un framework open source de Modélisation Mixte Marketing, propose une solution sophistiquée combinant des méthodes bayésiennes et des modèles d'ensemble pour des prédictions robustes. Ce guide détaillera l'implémentation de cette méthode.

Problématiques fondamentales

La modélisation de l'impact publicitaire doit adresser trois défis majeurs :

1. Effets retardés : L'impact d'une exposition ne se manifeste pas immédiatement et décroît dans le temps.
2. Rendements décroissants : L'effet marginal d'un investissement publicitaire diminue après un certain seuil.
3. Synergie entre canaux : L'efficacité d'un canal est influencée par la présence d'autres canaux dans le mix.

Préparation des données

Le framwork nécessite des données structurées comprenant :

• Les métriques d'exposition ou de dépense par canal médiatique.
• La variable cible (KPI) telle que les conversions ou le chiffre d'affaires.
• Des variables de contrôle externes (concurrence, saisonnalité).

Exemple de chargement et de construction du jeu de données :

import pandas as pd
from meridian.data import data_frame_input_data_builder

# Lecture des données sources
media_data = pd.read_csv('data/inputs/campagnes_q4.csv')

# Configuration du constructeur de données
data_constructor = data_frame_input_data_builder.DataFrameInputDataBuilder(kpi_type='revenue')
data_constructor = data_constructor.with_kpi(media_data, kpi_col='ca_total')
data_constructor = data_constructor.with_media(media_data, media_cols=['tv_impressions', 'search_clicks'],
                                              media_spend_cols=['tv_cout', 'search_cout'])
dataset = data_constructor.build()

Composants clés du modèle

Transformations Adstock et Hill

L'Adstock modélise la décroissance de la mémoire publicitaire. Sa forme géométrique se calcule ainsi :

def compute_adstock_weights(decay_rate, time_periods):
    """Calcule les poids de décroissance temporelle."""
    time_indices = tf.range(time_periods, dtype=tf.float32)
    weights = tf.pow(decay_rate, time_indices)
    normalized_weights = weights / tf.reduce_sum(weights)
    return normalized_weights

La fonction Hill caractérise les rendements décroisssants :

def apply_hill_saturation(media_values, half_effect_point, shape_parameter):
    """Applique la saturation des effets médiatiques."""
    numerator = tf.pow(media_values, shape_parameter)
    denominator = numerator + tf.pow(half_effect_point, shape_parameter)
    return numerator / denominator

Intégration avec les modèles d'ensemble

Meridian utilise un échantillonnage bayésien pour estimer les paramètres du modèle. L'entraînement s'effectue en plusieurs étapes :

from meridian.model import model as mmm_model

# Initialisation du modèle MMM
marketing_model = mmm_model.Meridian(input_data=dataset)

# Échantillonnage des distributions a priori
marketing_model.sample_prior(num_samples=300)

# Estimation des paramètres par échantillonnage MCMC
marketing_model.sample_posterior(num_chains=4, num_results=2000)

Flux de construction et de diagnostic

La spécification du modèle inclut le choix des distributions a priori pour les paramètres clés :

from meridian.model import spec, prior_distribution

# Définition des croyances initiales sur le ROI
roi_prior = prior_distribution.PriorDistribution(
    roi_distribution=tfp.distributions.LogNormal(loc=0.15, scale=0.7)
)

model_specification = spec.ModelSpec(
    prior=roi_prior,
    adstock_type='geometric'
)

La convergence de l'échantillonnage est vérifiée via des diagnostics statistiques. Un critère R-hat inférieur à 1.1 indique une bonne convergence des chaînes MCMC.

from meridian.analysis import visualizer

# Analyse des diagnostics du modèle
diagnostics_plotter = visualizer.ModelDiagnostics(marketing_model)
diagnostics_plotter.plot_rhat_boxplot()

# Visualisation de l'ajustement
fit_plotter = visualizer.ModelFit(marketing_model)
fit_plotter.plot_model_fit()

Optimisation de l'allocation budgétaire

Le module d'optimisation recherche la répartition des fonds qui maximise l'objectif spécifié (ex : ROI global) :

from meridian.analysis import optimizer

# Création de l'optimiseur
budget_optimizer = optimizer.BudgetOptimizer(marketing_model, target_column='ca_total')

# Lancement de l'optimisation sous contrainte de budget
optimal_allocation = budget_optimizer.optimize(
    total_budget=100000,
    constraints=[('search_cout', 20000, 40000)]
)

Évaluation des performances et bonnes pratiques

Les indicateurs de qualité du modèle incluent :

• Erreur absolue moyenne en pourcentage (MAPE) : Un MAPE inférieur à 7% est généralement acceptable.
• Couverture de l'intervalle de crédibilité : Les valeurs réelles devraient tomber dans l'intervalle à 80% de probabilité.
• Performance computationnelle : L'exécution sur un GPU accélère significativement l'échantillonnage posterior.

Recommandations :

1. Enrichir le modèle avec des variables de contexte pertinentes (effets calendaires).
2. Tester différents taux de décroissance pour l'Adstock (typiquement entre 0.6 et 0.85).
3. Valider les résultats sur une période de test hors échantillon.

Un cas d'usage dans le e-commerce a montré une amélioration de 15% du ROI global et une réduction de 30% de l'erreur de prédiction par rapport à une méthode linéaire traditionnelle.