Customer Lifetime Value

De Italiaanse econoom Vilfredo Pareto stelt dat 80% van het effect voortkomt uit 20% van de oorzaken; dit staat bekend als de 80/20-regel of het Paretoprincipe. Op dezelfde manier komt 80% van de omzet van bedrijven van 20% van de klanten. Bedrijven moeten die topklanten identificeren en de relatie met hen onderhouden om continue inkomsten te garanderen. Om een langdurige relatie met klanten te onderhouden, moeten bedrijven loyaliteitsprogramma's plannen, zoals kortingen, aanbiedingen, coupons, bonuspunten en cadeaus.

Een nieuwe klant targeten is duurder dan bestaande klanten behouden, omdat je geen middelen, tijd en extra inspanning hoeft te besteden om nieuwe klanten te werven. Je hoeft alleen je bestaande klanten tevreden te houden. Business analysts berekenen de klantacquisitiekosten nauwkeurig met CLTV (Customer Lifetime Value). CLTV geeft de totale omzet aan van de klant gedurende de hele relatie. CLTV helpt bedrijven zich te richten op die potentiële klanten die in de toekomst meer omzet kunnen opleveren.

Customer Lifetime Value (CLTV)

"Customer Lifetime Value is een geldwaarde die het bedrag aan omzet of winst vertegenwoordigt dat een klant het bedrijf zal opleveren gedurende de duur van de relatie". CLTV laat het verschil zien tussen het binnenhalen van langetermijnklanten en kortetermijnklanten. Customer lifetime value (CLV) helpt je de belangrijkste verkoopvragen voor elk bedrijf te beantwoorden:

• Hoe identificeer je de meest winstgevende klanten?
• Hoe kan een bedrijf het beste product aanbieden en het meeste verdienen?
• Hoe segmenteer je winstgevende klanten?
• Hoeveel budget moet je besteden om klanten te werven?

Customer Lifetime Value berekenen

Er zijn veel benaderingen om CLTV te berekenen. Iedereen heeft er zijn/haar eigen kijk op. Voor het berekenen van CLTV hebben we historische klantdata nodig, maar voor nieuwe klanten kun je die niet bepalen. Om dit op te lossen ontwikkelen business analysts machinelearningmodellen om de CLTV van nieuwe klanten te voorspellen. Laten we enkele benaderingen voor CLTV-berekening verkennen:

1) Je kunt het berekenen door winst/omzet van klanten in een bepaalde periode op te tellen. Bijvoorbeeld: als de klant de afgelopen 3 jaar bij je is, kun je alle winst in die 3 jaar optellen. Je kunt de winst middelen per jaar, halfjaar of maand, maar met deze aanpak kun je geen voorspellend model voor nieuwe klanten bouwen.

2) Bouw een regressiemodel voor bestaande klanten. Neem recente gegevens over zes maanden als onafhankelijke variabelen en de totale omzet over drie jaar als afhankelijke variabele en bouw hierop een regressiemodel.

3) CLTV kan ook worden toegepast met behulp van RFM (Recency, Frequency, Monetary)-waarden. Voor meer details kun je verwijzen naar mijn tutorial.

4) Met de volgende vergelijking: CLTV = ((Gemiddelde bestelwaarde × Aanko/frequentie)/Churnrate) × Winstmarge.

      Customer Value = Average Order Value * Purchase Frequency

• Average Order Value (AOV): De gemiddelde bestelwaarde is de verhouding tussen je totale omzet en het totale aantal bestellingen. AOV vertegenwoordigt het gemiddelde bedrag dat de klant aan een bestelling uitgeeft.

                       Average Order Value = Total Revenue / Total Number of Orders
  

• Purchase Frequency (PF): Aankoopfrequentie is de verhouding tussen het totale aantal bestellingen en het totale aantal klanten. Het vertegenwoordigt het gemiddelde aantal bestellingen per klant.

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

• Churnrate: Churnrate is het percentage klanten dat niet opnieuw heeft besteld.

• Klantlevensduur: Klantlevensduur is de periode waarin de klant continu bestellingen plaatst.

                                Customer Lifetime=1/Churn Rate
  

• Repeat rate: Repeat rate is de verhouding tussen het aantal klanten met meer dan één bestelling en het aantal unieke klanten. Voorbeeld: als je in een maand 10 klanten hebt van wie er 4 terugkomen, is je repeat rate 40%.

                                 Churn Rate= 1-Repeat Rate
  

CLTV-implementatie in Python (met formule)

Benodigde bibliotheken importeren

#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

Dataset laden

Laten we eerst de vereiste Online Retail-dataset laden met de pandas-functie read CSV. Je kunt de data hier downloaden.

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

data.head()

Duplicaten verwijderen

Soms krijg je een rommelige dataset. Je kunt dan te maken krijgen met duplicaten, die je analyse vertekenen. In Python biedt pandas de functie drop_duplicates(), die herhaalde of dubbele records verwijdert.

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

Laten we in de inzichten duiken

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

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

In de gegeven dataset zie je dat de meeste klanten uit "United Kingdom" komen. Je kunt de data dus filteren voor klanten uit het Verenigd Koninkrijk.

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

De functie describe() in pandas is handig voor diverse samenvattende statistieken. Deze functie geeft het aantal waarden, het gemiddelde, de standaardafwijking, de minimum- en maximumwaarden en de kwantielen van de data terug.

uk_data.describe()

Hier zie je dat sommige klanten een negatieve hoeveelheid hebben besteld, wat niet mogelijk is. Je moet Quantity dus filteren op groter dan nul.

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

Benodigde kolommen filteren

Hier kun je de noodzakelijke kolommen filteren voor het berekenen van CLTV. Je hebt slechts vijf kolommen nodig: CustomerID, InvoiceDate, InvoiceNo, Quantity en UnitPrice.

• CustomerID definieert je klanten uniek.
• InvoiceDate helpt je het aantal dagen te berekenen dat de klant bij je product is gebleven.
• InvoiceNo helpt je het aantal transacties te tellen (frequentie).
• Quantity is het aantal gekochte eenheden per transactie.
• UnitPrice van elke gekochte eenheid helpt je het totale aankoopbedrag te berekenen.

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

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

Hier ga je het volgende doen:

• Het aantal dagen berekenen tussen de huidige datum en de datum van de laatste aankoop per klant.
• Het aantal bestellingen per klant berekenen.
• De som van het aankoopbedrag per klant berekenen.

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

Kolommen hernoemen

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

CLTV berekenen met de volgende formule:

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

 Customer Value = Average Order Value * Purchase Frequency

1. Gemiddelde bestelwaarde berekenen

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

uk_data_group.head()

2. Aankoopfrequentie berekenen

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

3. Repeat rate en churnrate berekenen

# 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. Winstmarge berekenen

Winstmarge is de meest gebruikte winstgevendheidsratio. Het geeft aan welk percentage van de totale omzet als winst is behaald. Laten we aannemen dat ons bedrijf ongeveer 5% winst maakt op de totale verkoop.

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

uk_data_group.head()

5. Customer Lifetime Value berekenen

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

Voorspellingsmodel voor CLTV

Laten we het CLTV-voorspellingsmodel bouwen.

Hier ga je CLTV voorspellen met een lineair regressiemodel.

Laten we eerst de hierboven geladen en gefilterde data gebruiken.

uk_data.head()

Extraheer maand en jaar uit InvoiceDate.

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

uk_data.head()

De draaitabel (pivot table) neemt kolommen als input en groepeert de records in een tweedimensionale tabel die een multidimensionale samenvatting van de data biedt.

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

sale.head()

Laten we alle maandverkopen optellen.

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

sale.head()

Features selecteren

Hier moet je de gegeven kolommen opdelen in twee soorten variabelen: afhankelijke (of doelvariabele) en onafhankelijke variabelen (of featurevariabelen). Selecteer de laatste 6 maanden als onafhankelijke variabelen.

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

Data splitsen

Om de modelprestaties te begrijpen, is het een goede strategie om de dataset op te splitsen in een trainingsset en een testset.

Laten we de dataset splitsen met de functie train_test_split(). Je moet 3 parameters meegeven: features, target en test_set-grootte. Daarnaast kun je random_state gebruiken als seedwaarde om reproduceerbaarheid te behouden; dit betekent dat elke keer dat je splitst, de resultaten gelijk blijven. Als random_state None is, gebruikt de generator np.random om records willekeurig te selecteren. Dat betekent dat als je geen seed instelt, het elke keer anders is.

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

Modelontwikkeling

Importeer eerst de module Linear Regression en maak een Linear Regression-object. Fit vervolgens je model op de trainingsset met de functie fit() en voorspel op de testset met predict().

# 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]]

Hoe goed past het model bij de data?

Om de algehele fit van het lineaire model te evalueren, gebruiken we de R-kwadraatwaarde. R-kwadraat is het deel van de variantie dat door het model wordt verklaard. De waarde ligt tussen 0 en 1. Een hogere R-kwadraat wordt als beter beschouwd, omdat dit aangeeft dat het model een groter deel van de variantie verklaart.

from sklearn import metrics

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

R-Square: 0.9666074402817512

Dit model heeft een hoge R-kwadraat (0,96). Dit model past beter bij de data.

Modelevaluatie

Voor regressieproblemen worden de volgende evaluatiemetrics gebruikt (Ritchie Ng):

• Mean Absolute Error (MAE) is het gemiddelde van de absolute fouten.
• Mean Squared Error (MSE) is het gemiddelde van de gekwadrateerde fouten.
• Root Mean Squared Error (RMSE) is de vierkantswortel van het gemiddelde van de gekwadrateerde fouten.

# 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 is populairder dan MSE en MAE omdat RMSE interpreteerbaar is met y dankzij dezelfde eenheden.

Voor- en nadelen van CLTV

CLTV helpt je een effectief businessplan te ontwerpen en biedt ook de kans om je bedrijf te schalen. CLTV levert betekenisvolle klantsegmenten op; deze segmenten kunnen je helpen de behoeften van verschillende segmenten te identificeren.

Customer Lifetime Value is een tool, geen strategie. CLTV kan de meest winstgevende klanten achterhalen, maar hoe je daar winst mee maakt, hangt af van je strategie. Over het algemeen worden CLTV-modellen vaak verward en misbruikt. Een obsessie met CLTV kan oogkleppen creëren. Bedrijven focussen dan alleen op het vinden van de beste klantgroep en blijven daarop inzetten, maar het is ook belangrijk aandacht te geven aan andere klanten.

Conclusie

Gefeliciteerd, je bent aan het einde van deze tutorial gekomen!

In deze tutorial heb je veel details over Customer Lifetime Value behandeld. Je leerde wat customer lifetime value is, benaderingen voor het berekenen van CLTV, een implementatie van CLTV vanaf nul in Python, een voorspellingsmodel voor CLTV en de voor- en nadelen van CLTV. Ook heb je enkele basisconcepten van pandas behandeld, zoals groupby en draaitabellen, om geselecteerde kolommen en rijen van data samen te vatten.

Hopelijk kun je nu het CLTV-concept gebruiken om je eigen datasets te analyseren. Bedankt voor het lezen van deze tutorial!

Als je meer wilt leren over het analyseren van klantdata in Python, volg dan DataCamp's cursus Customer Analytics & A/B Testing in Python.