Customer Lifetime Value

Der italienische Ökonom Vilfredo Pareto stellte fest, dass 80% der Wirkung aus 20% der Ursachen stammen – bekannt als 80/20-Regel oder Pareto-Prinzip. Ähnlich verhält es sich im Business: 80% des Umsatzes kommen oft von 20% der Kundschaft. Unternehmen müssen diese Top-Kundinnen und -Kunden identifizieren und die Beziehung pflegen, um kontinuierliche Einnahmen zu sichern. Um langfristige Kundenbeziehungen aufzubauen, sollten Programme zur Kundenbindung geplant werden, etwa Rabatte, Angebote, Coupons, Bonuspunkte und Geschenke.

Neue Kundschaft zu gewinnen ist teurer, als bestehende zu halten, denn du musst weniger Ressourcen, Zeit und Aufwand investieren. Es gilt vor allem, bestehende Kundinnen und Kunden zufrieden zu stellen. Business-Analysten berechnen die Akquisitionskosten präzise mithilfe des CLTV (Customer Lifetime Value). Der CLTV zeigt den gesamten Umsatz, der während der gesamten Kundenbeziehung erzielt wird. Er hilft Unternehmen, sich auf diejenigen Kundensegmente zu konzentrieren, die künftig den meisten Umsatz bringen können.

Customer Lifetime Value (CLTV)

"Customer Lifetime Value ist ein Geldwert, der den Umsatz oder Gewinn repräsentiert, den eine Kundin oder ein Kunde dem Unternehmen über die gesamte Dauer der Beziehung bringt." CLTV macht den Unterschied zwischen langfristig und kurzfristig gebundenen Kundinnen und Kunden sichtbar. Der Customer Lifetime Value (CLV) hilft dir, die wichtigsten Vertriebsfragen in jedem Unternehmen zu beantworten:

• Wie identifiziere ich die profitabelsten Kundinnen und Kunden?
• Wie kann ein Unternehmen das beste Angebot machen und den höchsten Ertrag erzielen?
• Wie segmentiere ich profitable Kundensegmente?
• Wie viel Budget sollte in die Neukundengewinnung fließen?

Customer Lifetime Value berechnen

Es gibt viele Ansätze, um den CLTV zu berechnen. Jede Person hat dazu ihre eigene Sicht. Für die Berechnung benötigen wir historische Kundendaten – für neue Kundinnen und Kunden ist das zunächst nicht möglich. Um dieses Problem zu lösen, entwickeln Business-Analysten Machine-Learning-Modelle, die den CLTV für Neukundschaft vorhersagen. Lass uns ein paar Ansätze anschauen:

1) Du kannst den CLTV berechnen, indem du den Gewinn/Umsatz je Kundin bzw. Kunde über einen definierten Zeitraum aufsummierst. Beispiel: Wenn die Kundin seit 3 Jahren bei dir kauft, summierst du die Gewinne dieser 3 Jahre. Du kannst den Gewinn jährlich, halbjährlich oder monatlich mitteln. Mit diesem Ansatz lässt sich jedoch kein Vorhersagemodell für neue Kundinnen und Kunden bauen.

2) Baue ein Regressionsmodell für bestehende Kundschaft. Nutze die jüngsten sechs Monate als unabhängige Variablen und den Gesamtumsatz über drei Jahre als abhängige Variable und trainiere darauf ein Regressionsmodell.

3) CLTV lässt sich auch über RFM-Werte (Recency, Frequency, Monetary) implementieren. Mehr dazu findest du in meinem Tutorial.

4) Über folgende Gleichung: CLTV = ((Durchschnittlicher Bestellwert × Kaufhäufigkeit)/Churn-Rate) × Gewinnmarge.

      Customer Value = Average Order Value * Purchase Frequency

• Average Order Value (AOV): Der durchschnittliche Bestellwert ist das Verhältnis aus Gesamtumsatz und Gesamtanzahl der Bestellungen. Er zeigt, wie viel Umsatz im Mittel pro Bestellung erzielt wird.

                       Average Order Value = Total Revenue / Total Number of Orders
  

• Purchase Frequency (PF): Die Kaufhäufigkeit ist das Verhältnis aus Gesamtanzahl der Bestellungen und Gesamtanzahl der Kundinnen und Kunden. Sie zeigt, wie viele Bestellungen eine Person im Schnitt tätigt.

                      Purchase Frequency =  Total Number of Orders / Total Number of Customers
  

• Churn-Rate: Der Anteil der Kundinnen und Kunden, die nicht erneut bestellen.

• Kundenlebensdauer: Der Zeitraum, in dem eine Kundin oder ein Kunde kontinuierlich bestellt.

                                Customer Lifetime=1/Churn Rate
  

• Repeat-Rate: Das Verhältnis aus der Anzahl der Kundinnen und Kunden mit mehr als einer Bestellung zur Zahl der einzigartigen Kundinnen und Kunden. Beispiel: Wenn du in einem Monat 10 Kundinnen/Kunden hast und 4 davon zurückkommen, beträgt deine Repeat-Rate 40%.

                                 Churn Rate= 1-Repeat Rate
  

CLTV-Implementierung in Python (mit Formel)

Erforderliche Bibliotheken importieren

#import modules
import pandas as pd # for dataframes
import matplotlib.pyplot as plt # for plotting graphs
import seaborn as sns # for plotting graphs
import datetime as dt
import numpy as np

Datensatz laden

Lass uns zuerst den benötigten Online-Retail-Datensatz mit der pandas-Funktion read_csv laden. Du kannst die Daten hier herunterladen.

data = pd.read_excel("Online_Retail.xlsx")

data.head()

Duplikate entfernen

Manchmal sind Datensätze unaufgeräumt. Duplikate können deine Analyse verzerren. In Python bietet pandas die Funktion drop_duplicates(), die doppelte Einträge entfernt.

filtered_data=data[['Country','CustomerID']].drop_duplicates()

Lass uns in die Insights einsteigen

#Top ten country's customer
filtered_data.Country.value_counts()[:10].plot(kind='bar')

<matplotlib.axes._subplots.AxesSubplot at 0x7fe677a887f0>

Im gegebenen Datensatz stammen die meisten Kundinnen und Kunden aus dem „United Kingdom“. Du kannst die Daten also auf diese Gruppe filtern.

uk_data=data[data.Country=='United Kingdom']
uk_data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 495478 entries, 0 to 541893
Data columns (total 8 columns):
InvoiceNo      495478 non-null object
StockCode      495478 non-null object
Description    494024 non-null object
Quantity       495478 non-null int64
InvoiceDate    495478 non-null datetime64[ns]
UnitPrice      495478 non-null float64
CustomerID     361878 non-null float64
Country        495478 non-null object
dtypes: datetime64[ns](1), float64(2), int64(1), object(4)
memory usage: 34.0+ MB

Die describe()-Funktion in pandas liefert bequeme Übersichtsstatistiken. Sie gibt Anzahl, Mittelwert, Standardabweichung, Minimum, Maximum und Perzentile der Daten zurück.

uk_data.describe()

Hier siehst du, dass manche Bestellmengen negativ sind – das ist nicht plausibel. Also filtern wir Quantity > 0.

uk_data = uk_data[(uk_data['Quantity']>0)]
uk_data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 486286 entries, 0 to 541893
Data columns (total 8 columns):
InvoiceNo      486286 non-null object
StockCode      486286 non-null object
Description    485694 non-null object
Quantity       486286 non-null int64
InvoiceDate    486286 non-null datetime64[ns]
UnitPrice      486286 non-null float64
CustomerID     354345 non-null float64
Country        486286 non-null object
dtypes: datetime64[ns](1), float64(2), int64(1), object(4)
memory usage: 33.4+ MB

Benötigte Spalten filtern

Hier filterst du die relevanten Spalten für die CLTV-Berechnung. Du brauchst fünf Spalten: CustomerID, InvoiceDate, InvoiceNo, Quantity und UnitPrice.

• CustomerID identifiziert deine Kundinnen und Kunden eindeutig.
• InvoiceDate hilft, die Anzahl der Tage im Kundenlebenszyklus zu berechnen.
• InvoiceNo dient zur Zählung der Transaktionen (Frequenz).
• Quantity ist die Stückzahl pro Transaktion.
• UnitPrice ermöglicht zusammen mit Quantity die Berechnung des Gesamtbetrags.

uk_data=uk_data[['CustomerID','InvoiceDate','InvoiceNo','Quantity','UnitPrice']]

#Calulate total purchase
uk_data['TotalPurchase'] = uk_data['Quantity'] * uk_data['UnitPrice']

Als Nächstes führst du Folgendes aus:

• Berechne die Zahl der Tage zwischen dem ersten und letzten Kauf jeder Kundin/jedes Kunden.
• Zähle die Bestellungen pro Kundin/Kunde.
• Summiere die Einkaufsbeträge pro Kundin/Kunde.

uk_data_group=uk_data.groupby('CustomerID').agg({'InvoiceDate': lambda date: (date.max() - date.min()).days,
                                        'InvoiceNo': lambda num: len(num),
                                        'Quantity': lambda quant: quant.sum(),
                                        'TotalPurchase': lambda price: price.sum()})

uk_data_group.head()

Spalten umbenennen

# Change the name of columns
uk_data_group.columns=['num_days','num_transactions','num_units','spent_money']
uk_data_group.head()

CLTV mit folgender Formel berechnen:

 CLTV = ((Average Order Value x Purchase Frequency)/Churn Rate) x Profit margin.

 Customer Value = Average Order Value * Purchase Frequency

1. Durchschnittlichen Bestellwert berechnen

# Average Order Value
uk_data_group['avg_order_value']=uk_data_group['spent_money']/uk_data_group['num_transactions']

uk_data_group.head()

2. Kaufhäufigkeit berechnen

purchase_frequency=sum(uk_data_group['num_transactions'])/uk_data_group.shape[0]

3. Repeat-Rate und Churn-Rate berechnen

# Repeat Rate
repeat_rate=uk_data_group[uk_data_group.num_transactions > 1].shape[0]/uk_data_group.shape[0]

#Churn Rate
churn_rate=1-repeat_rate

purchase_frequency,repeat_rate,churn_rate

(90.37107880642694, 0.9818923743942872, 0.018107625605712774)

4. Gewinnmarge berechnen

Die Gewinnmarge ist eine gängige Profitabilitätskennzahl. Sie zeigt, wie viel Prozent des Umsatzes als Gewinn verbleiben. Nehmen wir an, unser Geschäft erzielt ca. 5% Marge auf den Gesamtumsatz.

# Profit Margin
uk_data_group['profit_margin']=uk_data_group['spent_money']*0.05

uk_data_group.head()

5. Customer Lifetime Value berechnen

# Customer Value
uk_data_group['CLV']=(uk_data_group['avg_order_value']*purchase_frequency)/churn_rate

#Customer Lifetime Value
uk_data_group['cust_lifetime_value']=uk_data_group['CLV']*uk_data_group['profit_margin']

uk_data_group.head()

Vorhersagemodell für CLTV

Lass uns ein CLTV-Vorhersagemodell bauen.

Hier sagst du den CLTV mit einem linearen Regressionsmodell voraus.

Wir nutzen die oben geladenen und gefilterten Daten.

uk_data.head()

Extrahiere Monat und Jahr aus InvoiceDate.

uk_data['month_yr'] = uk_data['InvoiceDate'].apply(lambda x: x.strftime('%b-%Y'))

uk_data.head()

Die Pivot-Tabelle gruppiert Spalten zu einer zweidimensionalen Ansicht und ermöglicht eine verdichtete, mehrdimensionale Zusammenfassung der Daten.

sale=uk_data.pivot_table(index=['CustomerID'],columns=['month_yr'],values='TotalPurchase',aggfunc='sum',fill_value=0).reset_index()

sale.head()

Jetzt summieren wir die Umsätze über alle Monate.

sale['CLV']=sale.iloc[:,2:].sum(axis=1)

sale.head()

Features auswählen

Teile die Spalten in Zielvariable (dependent) und Feature-Variablen (independent). Wähle die letzten 6 Monate als Features.

X=sale[['Dec-2011','Nov-2011', 'Oct-2011','Sep-2011','Aug-2011','Jul-2011']]
y=sale[['CLV']]

Daten aufteilen

Um die Modellleistung zu beurteilen, ist es sinnvoll, den Datensatz in Trainings- und Testmenge zu teilen.

Wir nutzen train_test_split(). Du übergibst Features, Zielvariable und die Größe des Testsets. Optional sorgt random_state als Seed für Reproduzierbarkeit. Ist random_state None, nutzt der Zufallszahlengenerator np.random – ohne Seed erhältst du bei jedem Split andere Ergebnisse.

#split training set and test set
from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,random_state=0)

Modellentwicklung

Importiere das Modul für lineare Regression und erstelle ein Objekt. Trainiere das Modell mit fit() auf dem Trainingsset und sage mit predict() auf dem Testset voraus.

# import model
from sklearn.linear_model import LinearRegression

# instantiate
linreg = LinearRegression()

# fit the model to the training data (learn the coefficients)
linreg.fit(X_train, y_train)

# make predictions on the testing set
y_pred = linreg.predict(X_test)

# print the intercept and coefficients
print(linreg.intercept_)
print(linreg.coef_)

[208.50969617]
[[0.99880551 0.80381254 1.60226829 1.67433228 1.52860813 2.87959449]]

Wie gut passt das Modell zu den Daten?

Zur Bewertung der Gesamtgüte nutzen wir R-Quadrat. Es beschreibt den durch das Modell erklärten Varianzanteil und liegt zwischen 0 und 1. Je höher, desto besser, da mehr Varianz erklärt wird.

from sklearn import metrics

# compute the R Square for model
print("R-Square:",metrics.r2_score(y_test, y_pred))

R-Square: 0.9666074402817512

Dieses Modell erreicht ein hohes R-Quadrat (0,96) und passt die Daten sehr gut.

Modellevaluation

Für Regressionsprobleme werden folgende Metriken genutzt (Ritchie Ng):

• Mean Absolute Error (MAE) ist der mittlere Betrag der Fehler.
• Mean Squared Error (MSE) ist der mittlere quadratische Fehler.
• Root Mean Squared Error (RMSE) ist die Quadratwurzel des MSE.

# calculate MAE using scikit-learn
print("MAE:",metrics.mean_absolute_error(y_test,y_pred))

#calculate mean squared error
print("MSE",metrics.mean_squared_error(y_test, y_pred))
# compute the RMSE of our predictions
print("RMSE:",np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

MAE: 595.0282284701234
MSE 2114139.8898678957
RMSE: 1454.0082151995896

RMSE ist beliebter als MSE und MAE, weil die Einheit der Zielvariable entspricht und dadurch intuitiver interpretierbar ist.

Vorteile und Nachteile von CLTV

CLTV hilft dir, einen wirksamen Geschäftsplan zu entwickeln und bietet Ansatzpunkte zum Skalieren. Zudem ermöglicht CLTV sinnvolle Kundensegmente, mit denen du die Bedürfnisse verschiedener Gruppen erkennst.

Customer Lifetime Value ist ein Werkzeug, keine Strategie. CLTV identifiziert die profitabelsten Kundinnen und Kunden – wie du daraus Profit schlägst, hängt von deiner Strategie ab. Häufig werden CLTV-Modelle missverstanden oder falsch verwendet. Eine zu starke Fixierung auf CLTV kann Scheuklappen erzeugen: Unternehmen fokussieren sich nur auf die vermeintlich besten Gruppen und wiederholen das Geschäft dort. Es ist jedoch ebenso wichtig, auch andere Kundinnen und Kunden im Blick zu behalten.

Fazit

Glückwunsch, du hast das Ende dieses Tutorials erreicht!

In diesem Tutorial hast du den Customer Lifetime Value im Detail kennengelernt: Definition, Ansätze zur Berechnung, eine Umsetzung in Python von Grund auf, ein Vorhersagemodell sowie die Vor- und Nachteile. Außerdem hast du grundlegende pandas-Konzepte wie groupby und Pivot-Tabellen genutzt, um ausgewählte Spalten und Zeilen zusammenzufassen.

Hoffentlich kannst du das CLTV-Konzept jetzt auf deine eigenen Datensätze anwenden. Danke fürs Lesen!

Wenn du mehr darüber lernen möchtest, Kundendaten in Python zu analysieren, schau dir den DataCamp-Kurs Customer Analytics & A/B Testing in Python an.