Introductie tot klantsegmentatie in Python

In de retailsector genereren de verschillende hypermarktketens een uitzonderlijk grote hoeveelheid data. Deze data wordt dagelijks in de winkels verzameld. Deze uitgebreide database met klanttransacties moet worden geanalyseerd om winstgevende strategieën te ontwikkelen.

Alle klanten hebben verschillende soorten behoeften. Met de groei van het klantenbestand en het aantal transacties is het niet eenvoudig om de wensen van elke klant te begrijpen. Het identificeren van potentiële klanten kan de marketingcampagne verbeteren, wat uiteindelijk de verkoop verhoogt. Segmentatie kan helpen door die klanten in verschillende segmenten te groeperen.

Wat is klantsegmentatie?

Klantsegmentatie is een methode om klanten in groepen of clusters te verdelen op basis van gemeenschappelijke kenmerken. Marktonderzoekers kunnen klanten in het B2C-model segmenteren op basis van diverse demografische kenmerken zoals beroep, geslacht, leeftijd, locatie en burgerlijke staat. Psychografische kenmerken zoals sociale klasse, levensstijl en persoonlijkheidskenmerken, en gedragskenmerken zoals bestedings- en consumptiegewoonten, gebruik van producten/diensten en eerder gekochte producten. In het B2B-model gebeurt segmentatie op basis van kenmerken van bedrijven, zoals de omvang van het bedrijf, het type industrie en de locatie.

Noodzaak van klantsegmentatie

• Het helpt bij het identificeren van de meest potentiële klanten.
• Het helpt managers om eenvoudig te communiceren met een gericht publiek.
• Helpt ook bij het kiezen van het beste kanaal om met het doelsegment te communiceren.
• Verbetert de kwaliteit van de service, loyaliteit en retentie.
• Verbetert de klantrelatie door de behoeften van segmenten beter te begrijpen.
• Biedt kansen voor upselling en cross-selling.
• Helpt managers om speciale aanbiedingen te ontwerpen voor doelklanten, om hen aan te moedigen meer producten te kopen.
• Helpt bedrijven een stap voor te blijven op concurrenten.
• Helpt ook bij het identificeren van nieuwe producten waarin klanten mogelijk geïnteresseerd zijn.

Typen segmentatie

Klantsegmentatie met RFM-analyse

RFM-analyse (Recency, Frequency, Monetary) is een gedragsgebaseerde aanpak om klanten in segmenten te groeperen. Het groepeert klanten op basis van hun eerdere aankooptransacties. Hoe recent, hoe vaak en hoeveel heeft een klant gekocht. RFM filtert klanten in verschillende groepen met het oog op betere service. Het helpt managers potentiële klanten te identificeren om winstgevender zaken te doen. Er is een segment klanten dat veel uitgeeft, maar wat als ze slechts één keer hebben gekocht of hoe recent hebben ze gekocht? Kopen ze vaak ons product? Ook helpt het managers om een effectieve promotiecampagne te voeren voor gepersonaliseerde service.

• Recency (R): Wie heeft onlangs gekocht? Aantal dagen sinds de laatste aankoop (lage recency is beter)
• Frequency (F): Wie koopt vaak? Dit betekent het totale aantal aankopen (hoge frequentie)
• Monetary Value (M): Wie heeft een hoog aankoopbedrag? Dit is het totale bedrag dat de klant heeft uitgegeven (hoge monetaire waarde)

Hier bestaat elk van de drie variabelen (Recency, Frequency en Monetary) uit vier gelijke groepen, wat 64 (4x4x4) verschillende klantsegmenten oplevert.

Stappen van RFM (Recency, Frequency, Monetary):

1. Bereken de Recency-, Frequency- en Monetary-waarden voor elke klant.
2. Voeg segmentbakwaarden toe aan de RFM-tabel met behulp van kwartielen.
3. Sorteer de RFM-score van de klant in oplopende volgorde.

1. Bereken de Recency-, Frequency- en Monetary-waarden voor elke klant.

2. Voeg segmentbakwaarden toe aan de RFM-tabel met behulp van kwartielen.

3. Voer alle scores samen in één kolom (RFM_Score).

Identificeer potentiële klantsegmenten met RFM in Python

Vereiste 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
Mogelijk gemaakt door

Dataset laden

Laten we eerst de vereiste HR-dataset laden met de pandas-functie read CSV. Je kunt de data via deze link downloaden.

data = pd.read_excel("Online_Retail.xlsx")
Mogelijk gemaakt door

data.head()
Mogelijk gemaakt door

data.tail()
Mogelijk gemaakt door

data.info()
Mogelijk gemaakt door

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 541909 entries, 0 to 541908
Data columns (total 8 columns):
InvoiceNo      541909 non-null object
StockCode      541909 non-null object
Description    540455 non-null object
Quantity       541909 non-null int64
InvoiceDate    541909 non-null datetime64[ns]
UnitPrice      541909 non-null float64
CustomerID     406829 non-null float64
Country        541909 non-null object
dtypes: datetime64[ns](1), float64(2), int64(1), object(4)
memory usage: 33.1+ MB
Mogelijk gemaakt door

data= data[pd.notnull(data['CustomerID'])]
Mogelijk gemaakt door

Dubbelen verwijderen

Soms krijg je een rommelige dataset. Je kunt te maken krijgen met dubbelen, 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()
Mogelijk gemaakt door

Laten we duiken in data-inzichten

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

<matplotlib.axes._subplots.AxesSubplot at 0x7fd81725dfd0>
Mogelijk gemaakt door

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

uk_data=data[data.Country=='United Kingdom']
Mogelijk gemaakt door

uk_data.info()
Mogelijk gemaakt door

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

De functie describe() in pandas is handig om verschillende samenvattende statistieken op te vragen. Deze functie retourneert het aantal waarden, het gemiddelde, de standaarddeviatie, de minimale en maximale waarden en de kwartielen van de data.

uk_data.describe()
Mogelijk gemaakt door

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

uk_data = uk_data[(uk_data['Quantity']>0)]Mogelijk gemaakt door

In: # Change the name of columns
rfm.columns=['monetary','frequency','recency']

uk_data.info() Mogelijk gemaakt door

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

Vereiste kolommen filteren

Hier kun je de noodzakelijke kolommen voor RFM-analyse filteren. Je hebt slechts vijf kolommen nodig: CustomerID, InvoiceDate, InvoiceNo, Quantity en UnitPrice. CustomerID identificeert je klanten uniek, InvoiceDate helpt je de recentheid van de aankoop te berekenen, InvoiceNo helpt je het aantal transacties te tellen (frequentie). Quantity die bij elke transactie is gekocht en UnitPrice van elke eenheid die door de klant is gekocht, helpen je om het totale aankoopbedrag te berekenen.

uk_data=uk_data[['CustomerID','InvoiceDate','InvoiceNo','Quantity','UnitPrice']]
Mogelijk gemaakt door

uk_data['TotalPrice'] = uk_data['Quantity'] * uk_data['UnitPrice']
Mogelijk gemaakt door

uk_data['InvoiceDate'].min(),uk_data['InvoiceDate'].max()
Mogelijk gemaakt door

(Timestamp('2010-12-01 08:26:00'), Timestamp('2011-12-09 12:49:00'))
Mogelijk gemaakt door

PRESENT = dt.datetime(2011,12,10)
uk_data['InvoiceDate'] = pd.to_datetime(uk_data['InvoiceDate'])
Mogelijk gemaakt door

uk_data.head()
Mogelijk gemaakt door

RFM-analyse

Hier ga je de volgende handelingen uitvoeren:

• Voor Recency: bereken het aantal dagen tussen de datum van vandaag en de datum van de laatste aankoop per klant.
• Voor Frequency: bereken het aantal bestellingen per klant.
• Voor Monetary: bereken de som van het aankoopbedrag per klant.

rfm= uk_data.groupby('CustomerID').agg({'InvoiceDate': lambda date: (PRESENT - date.max()).days,
                                        'InvoiceNo': lambda num: len(num),
                                        'TotalPrice': lambda price: price.sum()})
Mogelijk gemaakt door

rfm.columns
Mogelijk gemaakt door

Index(['InvoiceDate', 'TotalPrice', 'InvoiceNo'], dtype='object')
Mogelijk gemaakt door

# Change the name of columns rfm.columns=['recency', 'monetary', 'frequency'] Mogelijk gemaakt door

rfm['recency'] = rfm['recency'].astype(int)
Mogelijk gemaakt door

rfm.head()
Mogelijk gemaakt door

Kwartielen van RFM-waarden berekenen

Klanten met de laagste recency en de hoogste frequentie en monetaire bedragen worden beschouwd als topklanten.

qcut() is een op kwartielen gebaseerde discretisatiefunctie. qcut plaatst de data in bakken op basis van steekproefkwartielen. Bijvoorbeeld: 1000 waarden voor 4 kwartielen leveren een categorisch object op dat voor elke klant het bijbehorende kwartiel aangeeft.

rfm['r_quartile'] = pd.qcut(rfm['recency'], 4, ['1','2','3','4'])
rfm['f_quartile'] = pd.qcut(rfm['frequency'], 4, ['4','3','2','1'])
rfm['m_quartile'] = pd.qcut(rfm['monetary'], 4, ['4','3','2','1'])
Mogelijk gemaakt door

rfm.head()
Mogelijk gemaakt door

Interpretatie van RFM-resultaten

Combineer alle drie de kwartielen (r_quartile, f_quartile, m_quartile) in één kolom; deze ranking helpt je om klanten goed te segmenteren.

rfm['RFM_Score'] = rfm.r_quartile.astype(str)+ rfm.f_quartile.astype(str) + rfm.m_quartile.astype(str)
rfm.head()
Mogelijk gemaakt door

# Filter out Top/Best cusotmers
rfm[rfm['RFM_Score']=='111'].sort_values('monetary', ascending=False).head()
Mogelijk gemaakt door

Conclusie

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

In deze tutorial heb je veel details over klantsegmentatie behandeld. Je hebt geleerd wat klantsegmentatie is, waarom het nodig is, typen segmentatie, RFM-analyse en de implementatie van RFM vanaf nul in Python. Ook heb je enkele basisconcepten van pandas behandeld, zoals het omgaan met dubbelen, groupby en qcut() voor bakken op basis van steekproefkwartielen.

Hopelijk kun je nu topic modeling gebruiken om je eigen datasets te analyseren. Bedankt voor het lezen van deze tutorial!

Wil je meer leren over Python? Volg dan de gratis cursus Intro to Python for Data Science van DataCamp.