Churn modelling

Churn modelling: How to predict the churn?

This technical post is heavily derived from the week 03 of the ML Zoomcamp course offered by Alexey Grigorev and dataTalks.Club.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

Load the data

df = pd.read_csv('https://raw.githubusercontent.com/alexeygrigorev/mlbookcamp-code/master/chapter-03-churn-prediction/WA_Fn-UseC_-Telco-Customer-Churn.csv')

df.head().transpose()

df.columns = df.columns.str.lower()\
                       .str.replace(" ", "_")

df.columns

Index(['customerid', 'gender', 'seniorcitizen', 'partner', 'dependents',
       'tenure', 'phoneservice', 'multiplelines', 'internetservice',
       'onlinesecurity', 'onlinebackup', 'deviceprotection', 'techsupport',
       'streamingtv', 'streamingmovies', 'contract', 'paperlessbilling',
       'paymentmethod', 'monthlycharges', 'totalcharges', 'churn'],
      dtype='object')

df.isnull().sum().sort_values(ascending=False)

totalcharges        11
customerid           0
deviceprotection     0
monthlycharges       0
paymentmethod        0
paperlessbilling     0
contract             0
streamingmovies      0
streamingtv          0
techsupport          0
onlinebackup         0
gender               0
onlinesecurity       0
internetservice      0
multiplelines        0
phoneservice         0
tenure               0
dependents           0
partner              0
seniorcitizen        0
churn                0
dtype: int64

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 7043 entries, 0 to 7042
Data columns (total 21 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   customerid        7043 non-null   object 
 1   gender            7043 non-null   object 
 2   seniorcitizen     7043 non-null   int64  
 3   partner           7043 non-null   object 
 4   dependents        7043 non-null   object 
 5   tenure            7043 non-null   int64  
 6   phoneservice      7043 non-null   object 
 7   multiplelines     7043 non-null   object 
 8   internetservice   7043 non-null   object 
 9   onlinesecurity    7043 non-null   object 
 10  onlinebackup      7043 non-null   object 
 11  deviceprotection  7043 non-null   object 
 12  techsupport       7043 non-null   object 
 13  streamingtv       7043 non-null   object 
 14  streamingmovies   7043 non-null   object 
 15  contract          7043 non-null   object 
 16  paperlessbilling  7043 non-null   object 
 17  paymentmethod     7043 non-null   object 
 18  monthlycharges    7043 non-null   float64
 19  totalcharges      7043 non-null   object 
 20  churn             7043 non-null   object 
dtypes: float64(1), int64(2), object(18)
memory usage: 1.1+ MB

df["totalcharges"] = pd.to_numeric(df['totalcharges'], errors="coerce")

df["totalcharges"].isnull().sum()

11

df["totalcharges"] = df["totalcharges"].fillna(value=0)

New

df["churn"] = (df["churn"] == 'Yes').astype(int)

df.head()

df_train_full, df_test = train_test_split(df, test_size=0.2, random_state=1)

df_train, df_val = train_test_split(df_train_full, test_size=0.25, random_state=1)

df_train = df_train.reset_index(drop=True)
df_val = df_val.reset_index(drop=True)
df_test = df_test.reset_index(drop=True)

y_train = df_train["churn"].values
y_val = df_val["churn"].values
y_test = df_test["churn"].values

del df_train["churn"]
del df_val["churn"]
del df_test["churn"]

Exploratory Data Analysis

To understand the data in detail we will perform an exploratory data analysis.
Let's get started.

df_train_full.isnull().mean().sort_values(ascending=False)

customerid          0.0
deviceprotection    0.0
totalcharges        0.0
monthlycharges      0.0
paymentmethod       0.0
paperlessbilling    0.0
contract            0.0
streamingmovies     0.0
streamingtv         0.0
techsupport         0.0
onlinebackup        0.0
gender              0.0
onlinesecurity      0.0
internetservice     0.0
multiplelines       0.0
phoneservice        0.0
tenure              0.0
dependents          0.0
partner             0.0
seniorcitizen       0.0
churn               0.0
dtype: float64

df_train_full["churn"].value_counts(normalize=True)

0    0.730032
1    0.269968
Name: churn, dtype: float64

We can see that the churn rate is ~27%

df_train_full.dtypes

customerid           object
gender               object
seniorcitizen         int64
partner              object
dependents           object
tenure                int64
phoneservice         object
multiplelines        object
internetservice      object
onlinesecurity       object
onlinebackup         object
deviceprotection     object
techsupport          object
streamingtv          object
streamingmovies      object
contract             object
paperlessbilling     object
paymentmethod        object
monthlycharges      float64
totalcharges        float64
churn                 int64
dtype: object

numerical = ['tenure', 'monthlycharges', 'totalcharges']

df_train_full.columns

Index(['customerid', 'gender', 'seniorcitizen', 'partner', 'dependents',
       'tenure', 'phoneservice', 'multiplelines', 'internetservice',
       'onlinesecurity', 'onlinebackup', 'deviceprotection', 'techsupport',
       'streamingtv', 'streamingmovies', 'contract', 'paperlessbilling',
       'paymentmethod', 'monthlycharges', 'totalcharges', 'churn'],
      dtype='object')

categorical = ['gender', 'seniorcitizen', 'partner', 'dependents',
        'phoneservice', 'multiplelines', 'internetservice',
       'onlinesecurity', 'onlinebackup', 'deviceprotection', 'techsupport',
       'streamingtv', 'streamingmovies', 'contract', 'paperlessbilling',
       'paymentmethod']

df_train_full[categorical].nunique()

gender              2
seniorcitizen       2
partner             2
dependents          2
phoneservice        2
multiplelines       3
internetservice     3
onlinesecurity      3
onlinebackup        3
deviceprotection    3
techsupport         3
streamingtv         3
streamingmovies     3
contract            3
paperlessbilling    2
paymentmethod       4
dtype: int64

Feature Importance

churn_female = df_train_full[df_train_full["gender"] == 'Female']["churn"].mean()
churn_male = df_train_full[df_train_full["gender"] == 'Male']["churn"].mean()

for col in categorical:
    df_risk_group = df_train_full.groupby(col)['churn'].agg(['mean', 'count'])

    df_risk_group['diff'] = df_risk_group['mean'] - 0.2699
    df_risk_group['risk'] = df_risk_group['mean']/ 0.2699
    display(df_risk_group)

Mutual Information

From the sklearn documentation

Mutual Information is a measure of the similarity between two labels of the same data.

from sklearn.metrics import mutual_info_score

def mutual_info_churn_score(series):
    return mutual_info_score(series, df_train_full['churn'])

df_train_full[categorical].apply(mutual_info_churn_score).sort_values(ascending=False)

contract            0.098320
onlinesecurity      0.063085
techsupport         0.061032
internetservice     0.055868
onlinebackup        0.046923
deviceprotection    0.043453
paymentmethod       0.043210
streamingtv         0.031853
streamingmovies     0.031581
paperlessbilling    0.017589
dependents          0.012346
partner             0.009968
seniorcitizen       0.009410
multiplelines       0.000857
phoneservice        0.000229
gender              0.000117
dtype: float64

Correlation

df_train_full[numerical].corrwith(df_train_full['churn']).to_frame()

Tenure vs. Churn rate

Let's look at relation between the customers tenure and churn rate.

df_train_full[df_train_full['tenure'] <=2]['churn'].mean()

0.5953420669577875

df_train_full[(df_train_full['tenure'] > 2) & (df_train_full['tenure'] <= 12)]['churn'].mean()

0.3994413407821229

df_train_full[df_train_full['tenure'] > 12]['churn'].mean()

0.17634908339788277

Monthly Charges vs Churn rate

Let's take a look at the monthly charges vs Churn rate

df_train_full[df_train_full['monthlycharges'] <= 20]['churn'].mean()

0.08795411089866156

df_train_full[(df_train_full['monthlycharges'] > 20) & (df_train_full['monthlycharges'] <=50)]['churn'].mean()

0.18340943683409436

df_train_full[df_train_full['monthlycharges'] > 50]['churn'].mean()

0.32499341585462205

As shown the correlation is positive

One-hot encoding

DictVectorizer preserves the numerical column information while the categorical variables are one hot encoded. We fit the vectorizer on the training dataset and only transform the validation dataset.

from sklearn.feature_extraction import DictVectorizer

categorical

['gender',
 'seniorcitizen',
 'partner',
 'dependents',
 'phoneservice',
 'multiplelines',
 'internetservice',
 'onlinesecurity',
 'onlinebackup',
 'deviceprotection',
 'techsupport',
 'streamingtv',
 'streamingmovies',
 'contract',
 'paperlessbilling',
 'paymentmethod',
 'churn']

train_dicts = df_train[categorical+numerical].to_dict(orient="records")

dictvect = DictVectorizer(sparse=False)

dictvect.fit(train_dicts)

DictVectorizer(sparse=False)

DictVectorizer(sparse=False)

dictvect.feature_names_

['contract=Month-to-month',
 'contract=One year',
 'contract=Two year',
 'dependents=No',
 'dependents=Yes',
 'deviceprotection=No',
 'deviceprotection=No internet service',
 'deviceprotection=Yes',
 'gender=Female',
 'gender=Male',
 'internetservice=DSL',
 'internetservice=Fiber optic',
 'internetservice=No',
 'monthlycharges',
 'multiplelines=No',
 'multiplelines=No phone service',
 'multiplelines=Yes',
 'onlinebackup=No',
 'onlinebackup=No internet service',
 'onlinebackup=Yes',
 'onlinesecurity=No',
 'onlinesecurity=No internet service',
 'onlinesecurity=Yes',
 'paperlessbilling=No',
 'paperlessbilling=Yes',
 'partner=No',
 'partner=Yes',
 'paymentmethod=Bank transfer (automatic)',
 'paymentmethod=Credit card (automatic)',
 'paymentmethod=Electronic check',
 'paymentmethod=Mailed check',
 'phoneservice=No',
 'phoneservice=Yes',
 'seniorcitizen',
 'streamingmovies=No',
 'streamingmovies=No internet service',
 'streamingmovies=Yes',
 'streamingtv=No',
 'streamingtv=No internet service',
 'streamingtv=Yes',
 'techsupport=No',
 'techsupport=No internet service',
 'techsupport=Yes',
 'tenure',
 'totalcharges']

X_train = dictvect.transform(train_dicts)

X_train

array([[0.00000e+00, 0.00000e+00, 1.00000e+00, ..., 1.00000e+00,
        7.20000e+01, 8.42515e+03],
       [1.00000e+00, 0.00000e+00, 0.00000e+00, ..., 0.00000e+00,
        1.00000e+01, 1.02155e+03],
       [1.00000e+00, 0.00000e+00, 0.00000e+00, ..., 0.00000e+00,
        5.00000e+00, 4.13650e+02],
       ...,
       [1.00000e+00, 0.00000e+00, 0.00000e+00, ..., 1.00000e+00,
        2.00000e+00, 1.90050e+02],
       [0.00000e+00, 0.00000e+00, 1.00000e+00, ..., 0.00000e+00,
        2.70000e+01, 7.61950e+02],
       [1.00000e+00, 0.00000e+00, 0.00000e+00, ..., 0.00000e+00,
        9.00000e+00, 7.51650e+02]])

val_dicts = df_val[categorical+numerical].to_dict(orient="records")

X_val = dictvect.transform(val_dicts)

X_val

array([[0.0000e+00, 0.0000e+00, 1.0000e+00, ..., 1.0000e+00, 7.1000e+01,
        4.9734e+03],
       [1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00, 1.0000e+00,
        2.0750e+01],
       [1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00, 1.0000e+00,
        2.0350e+01],
       ...,
       [1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 1.0000e+00, 1.8000e+01,
        1.0581e+03],
       [1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00, 1.0000e+00,
        9.3300e+01],
       [1.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00, 3.0000e+00,
        2.9285e+02]])

Logistic Regression

$$y{i} = f(x{i})$$

Limits to values between 0 and 1, using a special function called sigmoid or logit.

$$ \sigma(z) = \frac{1}{1+e^{-z}} $$

where $\sigma(-\infty) = 0 $

def sigmoid(z):
    return 1/(1+ np.exp(-z))

z  = np.linspace(-10, 10, 100)

plt.plot(z, sigmoid(z))
plt.axvline(x=0,color='black', ls='--' )
plt.axhline(y=1.0, color='gray', ls='-.')
plt.axhline(y=0.5, color='gray', ls='-.')
plt.axhline(y=0.0, color='gray', ls='-.')

<matplotlib.lines.Line2D at 0x7f9145b0f760>

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

model.fit(X_train, y_train)

LogisticRegression()

LogisticRegression()

model.intercept_

array([-0.10906984])

model.coef_.round(3)

array([[ 0.475, -0.175, -0.407, -0.03 , -0.078,  0.063, -0.089, -0.081,
        -0.034, -0.073, -0.335,  0.316, -0.089,  0.004, -0.258,  0.141,
         0.009,  0.063, -0.089, -0.081,  0.266, -0.089, -0.284, -0.231,
         0.123, -0.166,  0.058, -0.087, -0.032,  0.07 , -0.059,  0.141,
        -0.249,  0.215, -0.12 , -0.089,  0.102, -0.071, -0.089,  0.052,
         0.213, -0.089, -0.232, -0.07 ,  0.   ]])

Hard predictions

model.predict(X_train)

array([0, 1, 1, ..., 1, 0, 1])

model.predict_proba(X_train)

array([[0.90443048, 0.09556952],
       [0.32074291, 0.67925709],
       [0.36639176, 0.63360824],
       ...,
       [0.4684025 , 0.5315975 ],
       [0.95750228, 0.04249772],
       [0.30138089, 0.69861911]])

y_pred = model.predict_proba(X_val)

y_pred

array([[0.99100249, 0.00899751],
       [0.79563017, 0.20436983],
       [0.78794861, 0.21205139],
       ...,
       [0.8636199 , 0.1363801 ],
       [0.20029807, 0.79970193],
       [0.16265877, 0.83734123]])

The first column gives us the probability of user not churning and the second column the probability of user churning.

Now, define a threshold of 0.5, to identify the users who could churn out.

churning_users = (y_pred[:, 1] > 0.5)

df_val[churning_users]['customerid']

3       8433-WXGNA
8       3440-JPSCL
11      2637-FKFSY
12      7228-OMTPN
19      6711-FLDFB
           ...    
1397    5976-JCJRH
1398    2034-CGRHZ
1399    5276-KQWHG
1407    6521-YYTYI
1408    3049-SOLAY
Name: customerid, Length: 311, dtype: object

y_val

array([0, 0, 0, ..., 0, 1, 1])

churning_users.astype(int)

array([0, 0, 0, ..., 0, 1, 1])

(y_val == churning_users).mean()

0.8034066713981547

df_predictions = pd.DataFrame()
df_predictions['churn_probability'] = y_pred[:, 1]
df_predictions['predicted'] = churning_users.astype(int)
df_predictions['actual'] = y_val
df_predictions['correct_predictions'] = (df_predictions['predicted'] == df_predictions['actual'])

df_predictions['correct_predictions'].mean()

0.8034066713981547

Model Interpretation

dict(zip(dictvect.feature_names_, model.coef_[0].round(3)))

{'contract=Month-to-month': 0.475,
 'contract=One year': -0.175,
 'contract=Two year': -0.407,
 'dependents=No': -0.03,
 'dependents=Yes': -0.078,
 'deviceprotection=No': 0.063,
 'deviceprotection=No internet service': -0.089,
 'deviceprotection=Yes': -0.081,
 'gender=Female': -0.034,
 'gender=Male': -0.073,
 'internetservice=DSL': -0.335,
 'internetservice=Fiber optic': 0.316,
 'internetservice=No': -0.089,
 'monthlycharges': 0.004,
 'multiplelines=No': -0.258,
 'multiplelines=No phone service': 0.141,
 'multiplelines=Yes': 0.009,
 'onlinebackup=No': 0.063,
 'onlinebackup=No internet service': -0.089,
 'onlinebackup=Yes': -0.081,
 'onlinesecurity=No': 0.266,
 'onlinesecurity=No internet service': -0.089,
 'onlinesecurity=Yes': -0.284,
 'paperlessbilling=No': -0.231,
 'paperlessbilling=Yes': 0.123,
 'partner=No': -0.166,
 'partner=Yes': 0.058,
 'paymentmethod=Bank transfer (automatic)': -0.087,
 'paymentmethod=Credit card (automatic)': -0.032,
 'paymentmethod=Electronic check': 0.07,
 'paymentmethod=Mailed check': -0.059,
 'phoneservice=No': 0.141,
 'phoneservice=Yes': -0.249,
 'seniorcitizen': 0.215,
 'streamingmovies=No': -0.12,
 'streamingmovies=No internet service': -0.089,
 'streamingmovies=Yes': 0.102,
 'streamingtv=No': -0.071,
 'streamingtv=No internet service': -0.089,
 'streamingtv=Yes': 0.052,
 'techsupport=No': 0.213,
 'techsupport=No internet service': -0.089,
 'techsupport=Yes': -0.232,
 'tenure': -0.07,
 'totalcharges': 0.0}