Uplift-Modellierung in Python

Einführung

Die Uplift-Modellierung ist eine Methode zur Gewinnmaximierung durch Marketingmaßnahmen. Sie können die Marketingeffizienz verbessern, indem Sie Kunden mit höheren Gewinnen ansprechen und Maßnahmen wie das Versenden von E-Mails und die Schaltung von Werbung ergreifen.

Dieser Artikel bietet einen Überblick über die Uplift-Modellierung und ein Memorandum mit Implementierungsbeispielen, um dies zu erreichen.

Uplift modeling

Überblick

** Die Uplift-Modellierung ist eine Methode zur Vorhersage der Gewinnsteigerung (die Differenz zwischen den Gewinnen bei der Implementierung einer Maßnahme und dem Gewinn bei der Nichtimplementierung) für Kunden mit einem bestimmten Attribut. ** Normale Vorhersageaufgaben für maschinelles Lernen sagen einfach voraus, wie auf eine Kennzahl reagiert werden soll (ob eine Reservierung vorgenommen werden soll oder nicht, wie hoch der Reservierungsbetrag ist usw.), aber die Uplift-Modellierung gilt für die Kennzahl. Sagen Sie voraus, wie sich die Reaktion ändern wird (wie sich die Reservierungswahrscheinlichkeit und der Reservierungsbetrag ändern werden). Durch die Klärung, wie sich die Reaktion der Kunden auf die Maßnahmen ändert, ist es möglich, die durchzuführenden Maßnahmen nur auf die hochwirksamen Kunden auszurichten und die Umsetzung der für jeden Kunden geeigneten Marketingmaßnahmen zu personalisieren. Was durch die Uplift-Modellierung vorhergesagt wird, kann als Gewinnsteigerung aufgrund der Implementierung von Maßnahmen umformuliert werden, wenn die Attribute von Kunden konditioniert sind (dh Kunden mit homogenen Attributen), also CATE (Conditional Average Treatment Effect), ITE Wird auch als (indivisueller Behandlungseffekt) bezeichnet.

Kundenklassifizierung in der Uplift-Modellierung

Im Rahmen der Uplift-Modellierung werden Kunden nach ihrer Reaktion auf Eingriffe (Umsetzung von Maßnahmen) (Conversion (CV) wie Klicks und Reservierungen) in vier Segmente eingeteilt.

** Iron Plate ** ist ein Kundenstamm, der mit oder ohne Intervention einen Lebenslauf erstellt. Wenn ein Eingriff kostspielig ist, ist er kostspielig und sollte nicht eingegriffen werden. Wenn beispielsweise ein aktiver Benutzer mit der neuesten Kaufhistorie in diese Ebene fällt und ohne Aufforderung zum Kauf per Postversand usw. einkauft, werden die Kosten für die Postzustellung verschwendet. ** Persuasive ** ist ein Kundenstamm, der nicht ohne Intervention, sondern nur mit Intervention einen Lebenslauf erstellt. Beispielsweise fallen Benutzer, die bereit sind zu kaufen, aber keinen Kauf tätigen können, in diese Gruppe, und durch das Verteilen von Rabattgutscheinen usw. kaufen Benutzer, die zu dieser Gruppe gehören, eher. ** Tenjiki ** ist ein Kundenstamm, der einen Lebenslauf ohne Intervention erstellt, aber keinen Lebenslauf mit Intervention. Es ist ein Kundenstamm, der niemals eingegriffen werden sollte, da eine Intervention den Gewinn mindert. ** Gleichgültigkeit ** ist ein Kundenstamm, der keinen Lebenslauf mit oder ohne Intervention erstellt. Wenn beispielsweise ein Benutzer, der seit dem letzten Kauf lange Zeit getrennt war oder inaktiv war, in diese Gruppe fällt und nicht mit einem Kauf rechnen kann, selbst wenn die Post zugestellt wird, können die Kosten durch Stoppen der Postzustellung gesenkt werden. Ich werde.

Die Uplift-Modellierung realisiert ein effizientes Marketing, indem sie den Kundenstamm identifiziert, der zur Überzeugungskraft gehört, und Maßnahmen für diese Kunden implementiert.

Hauptalgorithmen für die Uplift-Modellierung

Die Uplift-Modellierung verfügt über zwei Hauptalgorithmen. Einer wird als Meta-Learner-Algorithmus bezeichnet, der ein Modell (Basis-Learner genannt) erstellt, das die Vorteile von Intervention und Nicht-Intervention vorhersagt und die Gewinnsteigerung schätzt. Der andere heißt Uplift Tree. Hierbei handelt es sich um einen Algorithmus, der einen Baum erstellt, der eine Gruppe von Kunden anhand der Kriterien "Steigt die Gewinnsteigerung?" Teilt.

Meta-Learner-Algorithmus

Meta-Learner-Algorithmen werden weiter in Algorithmen wie T-Learner, S-Learner, X-Learner und R-Learner unterteilt, je nachdem, wie Sie die Vorteile von Intervention und Nicht-Intervention vorhersagen.

T-Learner Es ist ein Algorithmus, der die Gewinnsteigerung vorhersagt, indem er ein Modell erstellt, das den Gewinn beim Eingreifen vorhersagt, und ein Modell, das den Gewinn ohne Intervention separat vorhersagt und die Differenz zwischen den vorhergesagten Werten berücksichtigt. Da das Modell für den Fall der Intervention und den Fall ohne Intervention getrennt konstruiert ist, wird das Vorhandensein oder Fehlen einer Intervention nicht als Merkmalsgröße übernommen.

Wenn in einer Formel geschrieben,

\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) 

ist. Kundenhintergrundinformationen $ x $ (demografische Attribute, Kaufhistorie usw.) als Merkmalsmenge, ein Modell, das den Gewinn (Reservierungswahrscheinlichkeit, Reservierungsbetrag usw.) $ Y_1 $ beim Eingreifen und den Gewinn $ Y_0 ohne Intervention vorhersagt Erstellen Sie ein Modell, das $ vorhersagt, und die Differenz zwischen diesen vorhergesagten Werten $ \ hat {\ mu} _1 (x), \ hat {\ mu} _0 (x) $ ist die Gewinnsteigerung $ \ hat {\ tau } (x) $.

S-Learner Es ist ein Algorithmus, der die Gewinnsteigerung vorhersagt, indem er ein Modell erstellt, das den Gewinn vorhersagt, den Gewinn mit und ohne Intervention vorhersagt und die Differenz zwischen ihnen berücksichtigt. Im Gegensatz zu T-Learner wird das Vorhandensein oder Nichtvorhandensein einer Intervention als Merkmalsgröße verwendet.

Wenn in einer Formel geschrieben,

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

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

ist. Ein Modell, das den Gewinn $ Y $ mit Kundenhintergrundinformationen $ x $ und der Gruppenvariablen $ z $ ($ z = 1 $ steht für Intervention und $ z = 0 $) als Merkmal vorhersagt. Die Differenz zwischen dem vorhergesagten Wert $ \ hat {\ mu} (x, Z = 1) $ beim Konstruieren und Eingreifen und dem vorhergesagten Wert $ \ hat {\ mu} (x, Z = 0) $ beim Nicht-Eingreifen Die Gewinnsteigerung beträgt $ \ hat {\ tau} (x) $.

X-Learner Es ist ein Algorithmus, der die Gewinnsteigerung vorhersagt, indem die Pseudoeffekte (pseudoerhöhter Gewinn) mit und ohne Intervention geschätzt, gewichtet und addiert werden.

X-Learner erstellt zunächst ein Modell, das den Gewinn $ Y_1 $ beim Eingreifen vorhersagt, und ein Modell, das den Gewinn $ Y_0 $ ohne Intervention vorhersagt, wobei die Kundenhintergrundinformationen $ x $ als Merkmalsmenge verwendet werden.

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

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

Dann werden die Pseudoeffekte mit und ohne Intervention durch die folgende Formel geschätzt.

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

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

Die angegebenen Zahlen geben an, dass 1 Daten verwendet, die intervenierenden Kunden zugeordnet sind, und 0 Daten angibt, die nicht intervenierenden Kunden zugeordnet sind. $ D_i ^ 1 $ ist der Gewinn von $ Y_i ^ 1 $, der vom intervenierenden Kunden erzielt wird, und der Gewinn von $ \ hat {\ mu} \ _0 (x_i ^ 1) $, wenn der intervenierende Kunde nicht interveniert. Es ist der Unterschied und repräsentiert die Zunahme des Pseudo-Gewinns in der dazwischenliegenden Kundengruppe. $ D_i ^ 0 $ ist der Gewinn $ \ hat {\ mu} _1 (x \ _ i ^ 0) $, wenn der Kunde, der nicht eingegriffen hat, eingegriffen hat, und der Gewinn $ Y_i ^ von dem Kunden, der nicht eingegriffen hat. Dies ist eine Differenz von 0 $ und stellt eine Pseudo-Gewinnsteigerung für nicht intervenierende Kunden dar.

Erstellen Sie außerdem ein Modell, das Pseudoeffekte $ D_1, D_2 $ aus den Kundenhintergrundinformationen $ x $ vorhersagt.

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

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

Abwägen Sie schließlich den vorhergesagten Wert $ \ hat {\ tau} _0 (x) $ mit Intervention und den vorhergesagten Wert $ \ hat {\ tau} _1 (x) $ ohne Intervention mit $ g (x) $. Wir nehmen den Durchschnitt und prognostizieren die Gewinnsteigerung $ \ hat {\ tau} (x) $. Der Bereich von $ g (x) $ ist $ g (x) \ in \ [0,1] $, und als $ g (x) $ ist die Neigungsbewertung $ e (x) = P (Z = 1 | X = x Sie können auch) $ verwenden.

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

R-Learner R-Learner prognostiziert den durchschnittlichen Gewinn $ m (x) $, der von jedem Kunden erzielt wird, und den Neigungswert (= Wahrscheinlichkeit, dass der Kunde eingreift) $ e (x) $ sowie den Vorhersagefehler der Gewinnsteigerung Ist ein Algorithmus, der minimiert.

R-Learner erstellt zunächst ein Modell, das den durchschnittlichen Gewinn $ m (x) $ und den Neigungswert $ e (x) $ vorhersagt, wobei die Kundenhintergrundinformationen $ x $ als Feature verwendet werden.

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

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

Finden Sie dann die Gewinnsteigerung $ \ tau (・) $, so dass der Vorhersagefehler (Verlustfunktion) $ \ hat {L} \ _n (\ tau (・)) $ der Gewinnsteigerung minimiert wird. ..

\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 (・)) $ ist ein Regularisierungsterm. $ \ hat {m} ^ {(-i)} (x_i), \ hat {e} ^ {(-i)} (x_i) $ wird durch ein Modell vorhergesagt, das mit anderen Daten als den Daten des Kunden $ i $ erstellt wurde Repräsentiert den durchschnittlichen Gewinn- und Neigungswert des Kunden $ i $.

Uplift Tree Uplift Tree ist ein Algorithmus, der einen Baum erstellt, der eine Gruppe von Kunden auf der Grundlage von "Steigt die Gewinnsteigerung?" Der in der Binomialklassifizierungsaufgabe verwendete Entscheidungsbaum unterteilt die Gruppe nach bestimmten Attributen, so dass die Unreinheit der Klasse in der geteilten Population im Vergleich zu vor der Teilung verringert wird. Andererseits wird in Uplift Tree die Gruppe gemäß den Bedingungen für bestimmte Attribute aufgeteilt, so dass der Abstand zwischen der Gewinnverteilung der Gruppe mit Intervention und der Gewinnverteilung der Gruppe ohne Intervention in der geteilten Gruppe im Vergleich zu vor der Teilung zunimmt. Ich werde. Mit anderen Worten, wir werden die Kundengruppe durch Attribute teilen, die stark mit der Gewinnsteigerung zusammenhängen.

Wenn in einer Formel geschrieben,

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

Erstellen Sie den Baum so, dass $ D_ {gain} $ in definiert ist. $ P ^ T und P ^ C $ repräsentieren die Gewinnverteilung in der Interventions- bzw. Nicht-Interventionsgruppe, und $ D $ repräsentiert die Entfernung der Verteilung. Als $ D $ werden die Menge der Calvac / Libra-Informationen und die euklidische Entfernung verwendet.

Bewertungsindex der Uplift-Modellierung

Die Leistung der Uplift-Modellierung wird anhand eines Index mit dem Namen ** AUUC (Area Under the Uplift Curve) ** bewertet. AUUC ist ein normalisierter Indikator dafür, wie viel Gewinn steigen wird, wenn Sie nur bei Kunden eingreifen, deren Gewinn durch Uplift Moeling im Vergleich zu zufällig ausgewählten Kunden stark gesteigert wird. Je höher der AUUC-Wert ist, desto höher ist die Leistung der Uplift-Modellierung. Das Verfahren zur Berechnung der AUUC ist wie folgt.

1. Bewerten Sie jeden Kunden so, dass der Wert umso größer ist, je größer die durch die Uplift-Modellierung vorhergesagte Gewinnsteigerung ist. Hier wird diese Punktzahl als Uplift-Punktzahl bezeichnet. (Wenn Sie ein Verhältnis wie CVR als Gewinn verwenden, können Sie die Erhöhung des CVR als Erhöhungswert verwenden.)
2. Berechnen Sie, um wie viel sich der Gewinn erhöht hat, als Sie nur bei Kunden interveniert haben, deren Uplift-Score über dem Schwellenwert lag (hier wird dieser Wert als Lift bezeichnet), im Vergleich zu dem Zeitpunkt, als Sie nicht interveniert haben.
3. Berechnen Sie, um wie viel sich der in 2. erzielte Lift erhöht, indem Sie ihn mit der Gewinnsteigerung vergleichen, wenn die gleiche Anzahl von Kunden wie die Anzahl der Kunden, die in 2. eingreifen, zufällig ausgewählt und eingegriffen werden.
4. Fügen Sie die wiederholt berechneten Aufzüge hinzu, indem Sie den Schwellenwert von 2. und 3. ändern, und normalisieren Sie schließlich. (Die Kurve, die den durch Ändern des Schwellenwerts erhaltenen Auftrieb darstellt, wird als Auftriebskurve bezeichnet.)

Wenn in einer Formel geschrieben,

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))

ist. $ n $ steht für die Gesamtzahl der Kunden, $ k $ für die Anzahl der Kunden, deren Uplift-Score über dem Schwellenwert liegt, und $ \ pi $ für die Reihenfolge der Kunden (in absteigender Reihenfolge des Uplift Socre). $ AUL_ {\ pi} ^ T (k) $ wird angehoben, wenn bis zu $ k $ Kunden gemäß der Reihenfolge $ \ pi $ interveniert werden. $ AUL_ {\ pi} ^ C (k) $ ist zufällig Dies ist die Gewinnsteigerung bei der Auswahl und Intervention von $ k $ -Kunden. $ R_ {\ pi} ^ T (i) $ ist der Vorteil einer Intervention beim $ i $ -ten Kunden in der Reihenfolge $ \ pi $, $ R_ {\ pi} ^ C (i)) $ in der Reihenfolge $ Der Vorteil, nicht in den $ i $ -ten Kunden bei \ pi $ einzugreifen. $ \ bar {R} ^ T (k) $ ist der Vorteil einer Intervention in einer zufällig ausgewählten $ k $ Person, $ \ bar {R} ^ C (k) $ ist ein zufällig ausgewähltes $ k $ Es ist der Vorteil, nicht in Menschen einzugreifen. $ AUL_ {\ pi} ^ C (k) $ wird als Fläche eines Dreiecks mit einer Basis von $ k $ und einer Höhe von $ \ bar {R} ^ T (k) - \ bar {R} ^ C (k) $ angesehen Sie können auch daran denken.

Implementierungsbeispiel

Implementieren Sie in Python Code, der die Gewinnsteigerung durch Uplift-Modellierung vorhersagt. Hier werden T-Learner und S-Learner implementiert. Die Implementierung hier basiert auf Kapitel 9 von Maschinelles Lernen ab der Arbeit. Die Ausführungsumgebung ist Python 3.7.6, numpy 1.18.1, pandas 1.0.2, scikit-learn 0.22.2. Unten ist der Code.

• Laden der erforderlichen Bibliotheken

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

• Generierung der zu verwendenden Daten

Der Gewinn hier ist CVR.

def generate_sample_data(num, seed=0):
    cv_flg_list = [] #Liste der Flags, die die Konvertierung anzeigen
    treat_flg_list = [] #Eine Liste von Flags, die angeben, ob Sie eingegriffen haben
    feature_vector_list = [] #Liste der Funktionen
    
    feature_num = 8 #Anzahl der Funktionen
    base_weight = [0.02, 0.03, 0.05, -0.04, 0.00, 0.00, 0.00, 0.00] #Funktionsbasis
    lift_weight = [0.00, 0.00, 0.00, 0.05, -0.05, 0.00, 0.0, 0.00] #Änderungsbetrag des Funktionsbetrags während des Eingriffs
    
    random_instance = random.Random(seed)
    for i in range(num):
        feature_vector = [random_instance.random() for n in range(feature_num)] #Generiere zufällig Features
        treat_flg = random_instance.choice((1, 0)) #Generieren Sie zufällig Interventionsflags
        cv_rate = sum([feature_vector[n]*base_weight[n] for n in range(feature_num)]) #Generieren Sie den Basiswert von CVR
        if treat_flg == 1:
            cv_rate += sum([feature_vector[n]*lift_weight[n] for n in range(feature_num)]) #Heben Sie an, wenn Sie eingreifen möchten_Fügen Sie Gewicht hinzu und fügen Sie CVR hinzu
        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) #Modellbildungsdaten (Trainingsdaten)
test_data = generate_sample_data(num=10000, seed=1) #Daten zur Bewertung der Modellleistung (Verifizierungsdaten)

• Implementierung des T-Lerners

#Bereiten Sie Daten für ein Modell vor, das den Nutzen (CVR) einer Intervention vorhersagt
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']

#Bereiten Sie Daten für ein Modell vor, das den Nutzen (CVR) ohne Intervention vorhersagt
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']

#Baue zwei Modelle
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)

#CVR für Validierungsdaten vorhersagen
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]

#Berechnen Sie die Uplift-Punktzahl
uplift_score = treat_score - control_score

• Berechnung der AUUC

#Sortieren Sie die Verifizierungsdaten in absteigender Reihenfolge der Auftriebsbewertung
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)

#Berechnung des Auftriebs
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)

#Berechnung der AUUC
auuc = (result['lift'] - result['base_line']).sum() / len(result['lift'])
print('AUUC = {:.2f}'.format(auuc))
#Ausgabe:=> AUUC = 37.70

• Anhebungskurve zeichnen

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

--S-Learner Implementierung

#Vorbereitung von Trainingsdaten (Interaktionsbegriff zwischen Vorhandensein / Nichtvorhandensein einer Intervention und Merkmalsmenge erstellen)
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']

#Modell bauen
model = LogisticRegression(C=0.01, random_state=0)
model.fit(X_train, Y_train)

#Vorbereitung der Verifizierungsdaten bei Eingriffen
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]

#Erstellung von Verifizierungsdaten ohne 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]

#Prognostizieren Sie den Gewinn-CVR für Validierungsdaten
treat_score = model.predict_proba(X_test_treat)[:, 1]
control_score = model.predict_proba(X_test_control)[:, 1]

#Berechnung der Auftriebspunktzahl
uplift_score = treat_score - control_score

Wenn AUUC auf die gleiche Weise wie T-Learner bewertet wurde, ist AUUC = 19,60, und das Ergebnis dieser Daten ist, dass T-Learner eine höhere Leistung aufweist.

abschließend

Wir haben einen Überblick über die Uplift-Modellierung und ein Implementierungsbeispiel zusammengefasst, um dies zu erreichen. Wenn Sie Fehler finden, würden wir uns freuen, wenn Sie eine Bearbeitungsanfrage stellen könnten.

Referenz

• Maschinelles Lernen, um bei der Arbeit zu beginnen
• Maschinelles Lernen / Wirtschaftsmodell, Best Practice, Architektur für die Marketingautomatisierung von KI-Algorithmen
• uber/causalml: Uplift modeling and causal inference with machine learning algorithm
• A Large Scale Benchmark for Uplift Modeling