Modélisation Uplift en Python

introduction

La modélisation Uplift est une méthode pour maximiser les profits grâce à des mesures marketing. Vous pouvez améliorer l'efficacité du marketing en ciblant les clients avec des bénéfices plus élevés et en prenant des mesures telles que l'envoi d'e-mails et la diffusion de publicités.

Cet article fournit un aperçu de la modélisation Uplift et un exemple d'implémentation pour y parvenir à titre de rappel.

Uplift modeling

Aperçu

** La modélisation Uplift est une méthode de prédiction de l'augmentation des bénéfices (différence entre les bénéfices lorsque les mesures sont mises en œuvre et les bénéfices lorsque les mesures ne sont pas mises en œuvre) pour les clients avec certains attributs. ** Dans une tâche de prédiction d'apprentissage automatique normale, vous prédisez simplement comment vous allez réagir à une mesure (s'il faut ou non faire une réservation, quel est le montant de la réservation, etc.), mais dans la modélisation Uplift, vous ferez une prédiction pour la mesure. Prédisez comment la réaction changera (comment la probabilité de réservation et le montant de la réservation changeront). En clarifiant comment les réactions des clients aux mesures changent, il est possible de cibler des clients qui ne prennent des mesures que pour des clients très efficaces et de les personnaliser pour mettre en œuvre des mesures marketing adaptées à chaque client. Ce qui est prédit par la modélisation Uplift peut être reformulé comme l'augmentation du profit due à la mise en œuvre de mesures lorsque les attributs des clients sont conditionnés (c'est-à-dire des clients avec des attributs homogènes), donc CATE (Conditional Average Treatment Effect), ITE Aussi appelé (effet de traitement individuel).

Classification des clients dans la modélisation Uplift

Dans le cadre de la modélisation Uplift, les clients sont classés en quatre segments en fonction de leur réaction à l'intervention (mise en place de mesures) (conversion (CV) comme les clics et les réservations).

** Iron Plate ** est une base de clients qui CV avec ou sans intervention. Si l'intervention est coûteuse, elle est coûteuse et ne doit pas être intervenue. Par exemple, si un utilisateur actif qui a le dernier historique d'achat tombe dans cette couche et achète sans inviter l'achat par courrier électronique, etc., le coût de la livraison du courrier sera gaspillé. ** Persuasive ** est une clientèle qui ne CV sans intervention, mais uniquement avec intervention. Par exemple, les utilisateurs qui sont prêts à acheter mais ne peuvent pas faire d'achat appartiennent à ce groupe, et en distribuant des bons de réduction, etc., les utilisateurs appartenant à ce groupe sont plus susceptibles d'acheter. ** Tenjiki ** est une base de clients qui fait des CV sans intervention, mais plutôt pas des CV avec intervention. C'est une clientèle à laquelle il ne faut jamais intervenir, car une intervention réduira les profits. ** L'indifférence ** est une clientèle qui ne CV pas avec ou sans intervention. Par exemple, si un utilisateur qui a été séparé ou inactif pendant une longue période depuis le dernier achat appartient à ce groupe et ne peut pas s'attendre à acheter même si le courrier est livré, le coût peut être réduit en arrêtant la livraison du courrier. Je vais.

La modélisation Uplift réalise un marketing efficace en identifiant la clientèle qui appartient à la persuasion et en mettant en œuvre des mesures pour ces clients.

Principaux algorithmes pour la modélisation Uplift

La modélisation Uplift a deux algorithmes principaux. L'un s'appelle l'algorithme Meta-Learner, qui construit un modèle (appelé apprenant de base) qui prédit les avantages de l'intervention et de la non-intervention, et estime l'augmentation des bénéfices. L'autre s'appelle Uplift Tree, qui est un algorithme qui construit un arbre qui divise un groupe de clients sur la base des critères «L'augmentation des bénéfices augmentera-t-elle?

Algorithme Meta-Learner

Les algorithmes Meta-Learner sont en outre subdivisés en algorithmes tels que T-Learner, S-Learner, X-Learner et R-Learner, en fonction de la façon dont vous prédisez les avantages de l'intervention et de la non-intervention.

T-Learner C'est un algorithme qui prédit l'augmentation du profit en construisant un modèle qui prédit le profit lors de l'intervention et un modèle qui prédit le profit sans intervention séparément et en prenant la différence entre les valeurs prédites. Puisque le modèle est construit séparément pour le cas d'intervention et le cas de non intervention, la présence ou l'absence d'intervention n'est pas adoptée comme une grandeur caractéristique.

Lorsqu'il est écrit dans une formule,

\mu_1(x) = E(Y_1 | X=x)

\mu_0(x) = E(Y_0 | X=x)

\hat{\tau}(x) = \hat{\mu}_1(x) - \hat{\mu}_0(x) 

est. Informations de base du client $ x $ (attributs démographiques, historique des achats, etc.) en tant que quantité de caractéristiques, un modèle qui prédit le profit (probabilité de réservation, montant de la réservation, etc.) $ Y_1 $ lors de l'intervention et le profit $ Y_0 sans intervention Construisez un modèle qui prédit $, et la différence entre ces valeurs prédites $ \ hat {\ mu} _1 (x), \ hat {\ mu} _0 (x) $ est l'augmentation du profit $ \ hat {\ tau } (x) $.

S-Learner C'est un algorithme qui prédit l'augmentation du profit en construisant un modèle qui prédit le profit, en prédisant le profit avec et sans intervention et en prenant la différence entre eux. Contrairement à T-Learner, la présence ou l'absence d'intervention est adoptée comme quantité de caractéristique.

Lorsqu'il est écrit dans une formule,

\mu(x, z) = E(Y | X=x, Z=z)

\hat{\tau}(x) = \hat{\mu}(x, Z=1) - \hat{\mu}(x, Z=0)

est. Un modèle qui prédit le profit $ Y $ en utilisant les informations de base du client $ x $ et la variable de groupe $ z $ ($ z = 1 $ représente l'intervention et $ z = 0 $) indiquant la présence ou l'absence d'intervention. La différence entre la valeur prédite $ \ hat {\ mu} (x, Z = 1) $ lors de la construction et de l'intervention et la valeur prédite $ \ hat {\ mu} (x, Z = 0) $ lorsque vous n'intervenez pas , L'augmentation du profit sera $ \ hat {\ tau} (x) $.

X-Learner C'est un algorithme qui prédit l'augmentation du profit en estimant les pseudo-effets (pseudo-profit accru) avec et sans intervention, en les pondérant et en les additionnant.

X-Learner construit d'abord un modèle qui prédit le profit $ Y_1 $ lors de l'intervention et un modèle qui prédit le profit $ Y_0 $ sans intervention, en utilisant les informations de base du client $ x $ comme quantité de caractéristiques.

\mu_1(x) = E(Y_1 | X=x)

\mu_0(x) = E(Y_0 | X=x)

Ensuite, les pseudo-effets avec et sans intervention sont estimés par la formule suivante.

D_i^1 = Y_i^1 - \hat{\mu}_0(x_i^1)

D_i^0 = \hat{\mu}_1(x_i^0) - Y_i^0 

Le nombre en exposant indique que 1 utilise des données associées au client intervenant et 0 indique des données associées au client non intervenant. $ D_i ^ 1 $ est le profit $ Y_i ^ 1 $ obtenu du client intervenant et le profit $ \ hat {\ mu} \ _0 (x_i ^ 1) $ si le client intervenant n'est pas intervenu. C'est la différence et représente l'augmentation du pseudo-profit dans le groupe de clients intervenant. $ D_i ^ 0 $ est le profit $ \ hat {\ mu} _1 (x \ _ i ^ 0) $ si le client qui n'est pas intervenu est intervenu, et le profit $ Y_i ^ obtenu du client qui n'est pas intervenu. Il s'agit d'une différence de 0 $ et représente une augmentation de pseudo-profit pour les clients non intervenants.

De plus, créez un modèle qui prédit les pseudo-effets $ D_1, D_2 $ à partir des informations de base du client $ x $.

\tau_1(x) = E(D_1 | X=x)

\tau_0(x) = E(D_0 | X=x)

Enfin, pesez la valeur prédite $ \ hat {\ tau} _0 (x) $ avec intervention et la valeur prédite $ \ hat {\ tau} _1 (x) $ sans intervention avec $ g (x) $. Nous prenons la moyenne et prédisons l'augmentation des bénéfices $ \ hat {\ tau} (x) $. La plage de $ g (x) $ est $ g (x) \ in \ [0,1] $, et le score de propension $ e (x) = P (Z = 1 | X = x) pour $ g (x) $. Vous pouvez également utiliser) $.

\hat{\tau}(x) = g(x)\hat{\tau}_0(x)+(1-g(x))\hat{\tau}_1(x)

R-Learner R-Learner prédit le profit moyen $ m (x) $ obtenu de chaque client et le score de propension (= probabilité que le client intervienne) $ e (x) $, et l'erreur de prédiction de l'augmentation du profit Est un algorithme qui minimise.

R-Learner construit d'abord un modèle qui prédit le profit moyen $ m (x) $ et le score de propension $ e (x) $, en utilisant les informations de base du client $ x $ comme une fonctionnalité.

m(x) = E(Y | X=x)

e(x) = P(Z=1 | X=x)

Ensuite, trouvez l'augmentation du bénéfice $ \ tau (・) $ de sorte que l'erreur de prédiction (fonction de perte) $ \ hat {L} \ _n (\ tau (・)) $ de l'augmentation du profit soit minimisée. ..

\hat{\tau}(・) = argmin_{\tau}\{\hat{L}_n(\tau(・)) + \Lambda_n(\tau(・))\}

\hat{L_n(\tau(・))} = \frac{1}{n}\sum_{i=1}^n((Y_i-\hat{m}^{(-i)}(x_i))-(z_i-\hat{e}^{(-i)}(x_i))\tau(x_i))^2

$ \ Lambda_n (\ tau (・)) $ est un terme de régularisation. $ \ hat {m} ^ {(-i)} (x_i), \ hat {e} ^ {(-i)} (x_i) $ est prédit par un modèle construit avec des données autres que les données du client $ i $ Représente le score moyen de profit et de propension du client $ i $.

Uplift Tree Uplift Tree est un algorithme qui construit un arbre qui divise un groupe de clients sur la base de "L'augmentation des bénéfices augmentera-t-elle?" L'arbre de décision utilisé dans la tâche de classification binomiale divise le groupe selon certains attributs de sorte que l'impureté de la classe dans la population divisée est réduite par rapport à avant la division. En revanche, dans Uplift Tree, le groupe est divisé selon les conditions liées à certains attributs de sorte que la distance entre la répartition des bénéfices du groupe avec intervention et la répartition des bénéfices du groupe sans intervention dans le groupe divisé augmente par rapport à avant la division. Je vais. En d'autres termes, nous diviserons le groupe de clients par des attributs fortement liés à l'augmentation des bénéfices.

Lorsqu'il est écrit dans une formule,

D_{gain} = D_{after-split}(P^T, P^C) - D_{before-split}(P^T, P^C)

Construisez l'arborescence de sorte que $ D_ {gain} $ défini dans soit grand. $ P ^ T et P ^ C $ représentent la distribution des bénéfices dans les groupes d'intervention et de non-intervention, respectivement, et $ D $ représente la distance de la distribution. En $ D $, la quantité d'informations Calvac / Balance et la distance euclidienne sont utilisées.

Indice d'évaluation de la modélisation Uplift

Les performances de la modélisation Uplift sont évaluées à l'aide d'un indice appelé ** AUUC (Area Under the Uplift Curve) **. L'AUUC est une mesure normalisée du profit qui augmentera si vous n'intervenez que chez les clients qui ont une forte augmentation de profit prévue par Uplift moeling par rapport à une intervention sur des clients sélectionnés au hasard. Plus la valeur AUUC est élevée, plus les performances de la modélisation Uplift sont élevées. La procédure de calcul de l'AUUC est la suivante.

1. Notez chaque client de sorte que plus l'augmentation du profit prévue par la modélisation Uplift est importante, plus la valeur est élevée. Ici, ce score est appelé le score de soulèvement. (Si vous utilisez un ratio tel que le CVR comme bénéfice, vous pouvez utiliser l'augmentation du CVR comme un score d'augmentation.)
2. Calculez combien le profit a augmenté lorsque vous êtes intervenu uniquement chez les clients dont le score de hausse était supérieur au seuil (ici, cette valeur est appelée lift) par rapport au moment où vous n'êtes pas intervenu.
3. Calculez combien l'ascenseur obtenu en 2. augmentera en comparant avec l'augmentation du profit lorsque le même nombre de clients que le nombre de clients qui interviennent en 2. sont choisis au hasard et sont intervenus.
4. Ajoutez les ascenseurs calculés à plusieurs reprises en changeant le seuil de 2. et 3., et enfin normaliser. (La courbe qui trace la portance obtenue en modifiant le seuil est appelée courbe de soulèvement.)

Lorsqu'il est écrit dans une formule,

AUUC = \sum_{k=1}^n AUUC_{\pi}(k)

AUUC_{\pi}(k) =  AUL_{\pi}^T(k) - AUL_{\pi}^C(k) = \sum_{i=1}^k (R_{\pi}^T(i) - R_{\pi}^C(i)) - \frac{k}{2}(\bar{R}^T(k) - \bar{R}^C(k))

est. $ n $ représente le nombre total de clients, $ k $ représente le nombre de clients dont le score d'augmentation est au-dessus du seuil, et $ \ pi $ représente l'ordre des clients (par ordre décroissant du socre d'augmentation). $ AUL_ {\ pi} ^ T (k) $ est lifté en intervenant jusqu'à $ k $ clients selon la commande $ \ pi $, $ AUL_ {\ pi} ^ C (k) $ est aléatoire Il s'agit de l'augmentation des bénéfices lors de la sélection et de l'intervention des clients $ k $. $ R_ {\ pi} ^ T (i) $ est l'avantage d'intervenir chez le $ i $ ème client dans la commande $ \ pi $, $ R_ {\ pi} ^ C (i)) $ est la commande $ L'avantage de ne pas intervenir chez le $ i $ ème client à \ pi $. $ \ bar {R} ^ T (k) $ est l'avantage d'intervenir dans une personne $ k $ choisie au hasard, $ \ bar {R} ^ C (k) $ est un $ k $ choisi au hasard C'est l'avantage de ne pas intervenir chez les gens. $ AUL_ {\ pi} ^ C (k) $ est vu comme l'aire d'un triangle avec une base de $ k $ et une hauteur de $ \ bar {R} ^ T (k) - \ bar {R} ^ C (k) $ Vous pouvez aussi y penser.

Exemple d'implémentation

En Python, implémentez un code qui prédit l'augmentation des bénéfices grâce à la modélisation Uplift. Ici, T-Learner et S-Learner sont implémentés. La mise en œuvre ici est basée sur le chapitre 9 de L'apprentissage automatique à partir du travail. L'environnement d'exécution est Python 3.7.6, numpy 1.18.1, pandas 1.0.2, scikit-learn 0.22.2. Ci-dessous le code.

--Chargement des bibliothèques requises

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
sns.set_style('whitegrid')
import random

from sklearn.linear_model import LogisticRegression

--Génération de données à utiliser

Le profit ici est CVR.

def generate_sample_data(num, seed=0):
    cv_flg_list = [] #Liste des indicateurs indiquant la conversion
    treat_flg_list = [] #Une liste d'indicateurs qui indiquent si vous êtes intervenu
    feature_vector_list = [] #Liste des fonctionnalités
    
    feature_num = 8 #Nombre de fonctionnalités
    base_weight = [0.02, 0.03, 0.05, -0.04, 0.00, 0.00, 0.00, 0.00] #Base de fonctionnalités
    lift_weight = [0.00, 0.00, 0.00, 0.05, -0.05, 0.00, 0.0, 0.00] #Montant de la modification du montant de la fonction pendant l'intervention
    
    random_instance = random.Random(seed)
    for i in range(num):
        feature_vector = [random_instance.random() for n in range(feature_num)] #Générer des fonctionnalités de manière aléatoire
        treat_flg = random_instance.choice((1, 0)) #Générer aléatoirement des indicateurs d'intervention
        cv_rate = sum([feature_vector[n]*base_weight[n] for n in range(feature_num)]) #Générer la valeur de base du CVR
        if treat_flg == 1:
            cv_rate += sum([feature_vector[n]*lift_weight[n] for n in range(feature_num)]) #Soulevez si vous souhaitez intervenir_Ajouter du poids et ajouter CVR
        cv_flg = 1 if cv_rate > random_instance.random() else 0
        
        cv_flg_list.append(cv_flg)
        treat_flg_list.append(treat_flg)
        feature_vector_list.append(feature_vector)
    
    df = pd.DataFrame(np.c_[cv_flg_list, treat_flg_list, feature_vector_list], 
                      columns=['cv_flg', 'treat_flg','feature0', 'feature1', 'feature2', 
                               'feature3', 'feature4', 'feature5', 'feature6', 'feature7'])
    
    return df

train_data = generate_sample_data(num=10000, seed=0) #Modèle de données de construction (données d'entraînement)
test_data = generate_sample_data(num=10000, seed=1) #Données d'évaluation des performances du modèle (données de vérification)

--Mise en œuvre de T-Learner

#Préparer des données pour un modèle qui prédit le bénéfice (CVR) de l'intervention
X_train_treat = train_data[train_data['treat_flg']==1].drop(['cv_flg', 'treat_flg'], axis=1)
Y_train_treat = train_data.loc[train_data['treat_flg']==1, 'cv_flg']

#Préparer des données pour un modèle qui prédit le bénéfice (CVR) sans intervention
X_train_control = train_data[train_data['treat_flg']==0].drop(['cv_flg', 'treat_flg'], axis=1)
Y_train_control = train_data.loc[train_data['treat_flg']==0, 'cv_flg']

#Construisez deux modèles
treat_model = LogisticRegression(C=0.01, random_state=0)
control_model = LogisticRegression(C=0.01, random_state=0)
treat_model.fit(X_train_treat, Y_train_treat)
control_model.fit(X_train_control, Y_train_control)

#Prédire le CVR pour les données de validation
X_test = test_data.drop(['cv_flg', 'treat_flg'], axis=1)

treat_score = treat_model.predict_proba(X_test)[:, 1]
control_score = control_model.predict_proba(X_test)[:, 1]

#Calculer le score d'augmentation
uplift_score = treat_score - control_score

--Calcul de l'AUUC

#Trier les données de vérification dans l'ordre décroissant du score d'augmentation
result = pd.DataFrame(np.c_[test_data['cv_flg'], test_data['treat_flg'], uplift_score], columns=['cv_flg', 'treat_flg', 'uplift_score'])
result = result.sort_values(by='uplift_score', ascending=False).reset_index(drop=True)

#Calcul de la portance
result['treat_num_cumsum'] = result['treat_flg'].cumsum()
result['control_num_cumsum'] = (1 - result['treat_flg']).cumsum()
result['treat_cv_cumsum'] = (result['treat_flg'] * result['cv_flg']).cumsum()
result['control_cv_cumsum'] = ((1 - result['treat_flg']) * result['cv_flg']).cumsum()
result['treat_cvr'] = (result['treat_cv_cumsum'] / result['treat_num_cumsum']).fillna(0)
result['control_cvr'] = (result['control_cv_cumsum'] / result['control_num_cumsum']).fillna(0)
result['lift'] = (result['treat_cvr'] - result['control_cvr']) * result['treat_num_cumsum']
result['base_line'] = result.index * result['lift'][len(result.index) - 1] / len(result.index)

#Calcul de l'AUUC
auuc = (result['lift'] - result['base_line']).sum() / len(result['lift'])
print('AUUC = {:.2f}'.format(auuc))
#production:=> AUUC = 37.70

• Dessin de la courbe de soulèvement

result.plot(y=['lift', 'base_line'])
plt.xlabel('uplift score rank')
plt.ylabel('conversion lift')
plt.show()

• Implémentation de S-Learner

#Préparation des données d'entraînement (créer un terme d'interaction entre la présence / l'absence d'intervention et la quantité de fonctionnalités)
X_train = train_data.drop('cv_flg', axis=1)
for feature in ['feature'+str(i) for i in range(8)]:
    X_train['treat_flg_x_' + feature] = X_train['treat_flg'] * X_train[feature]
Y_train = train_data['cv_flg']

#Construire un modèle
model = LogisticRegression(C=0.01, random_state=0)
model.fit(X_train, Y_train)

#Préparation des données de vérification lors de l'intervention
X_test_treat = test_data.drop('cv_flg', axis=1).copy()
X_test_treat['treat_flg'] = 1
for feature in ['feature'+str(i) for i in range(8)]:
    X_test_treat['treat_flg_x_' + feature] = X_test_treat['treat_flg'] * X_test_treat[feature]

#Préparation des données de vérification sans intervention
X_test_control = test_data.drop('cv_flg', axis=1).copy()
X_test_control['treat_flg'] = 0
for feature in ['feature'+str(i) for i in range(8)]:
    X_test_control['treat_flg_x_' + feature] = X_test_control['treat_flg'] * X_test_control[feature]

#Prédire le CVR des bénéfices pour les données de validation
treat_score = model.predict_proba(X_test_treat)[:, 1]
control_score = model.predict_proba(X_test_control)[:, 1]

#Calcul du score d'augmentation
uplift_score = treat_score - control_score

Lorsque AUUC a été évalué de la même manière que T-Learner, AUUC = 19,60, et le résultat de ces données est que T-Learner a des performances plus élevées.

en conclusion

Nous avons résumé un aperçu de la modélisation Uplift et un exemple de mise en œuvre pour y parvenir. Si vous trouvez des erreurs, nous vous serions reconnaissants de bien vouloir faire une demande de modification.

référence

• L'apprentissage automatique pour commencer au travail
• Apprentissage automatique / modèle économique, bonnes pratiques, architecture pour l'automatisation du marketing d'algorithmes d'IA
• uber/causalml: Uplift modeling and causal inference with machine learning algorithm
• A Large Scale Benchmark for Uplift Modeling