Customer Data Churn Analysis

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import os
print(os.listdir("../input"))
import warnings
warnings.filterwarnings("ignore")

df = pd.read_csv("../input/WA_Fn-UseC_-Telco-Customer-Churn.csv",na_values = [" "])
df.head()

# check NA
df.isna().sum()

# drop NA
df = df.dropna()

# drop customerID and churn to make train dataset
customerID = df["customerID"]
Churn = df["Churn"]
df = df.drop(["customerID","Churn"],axis = 1)

# change data type :
df["SeniorCitizen"] = df["SeniorCitizen"].astype("object")

print(df.dtypes)

# Churn Rate
print(Churn.value_counts())
print("-"*40)
print("Churn Rate", sum(Churn == "Yes")/len(Churn))

# plot numeric values
_,ax = plt.subplots(3,1,figsize = (9,9))
for i,c in enumerate(df.select_dtypes([np.number]).columns) :
    # print(i,c)
    sns.distplot(df[c],ax = ax[i])

_,ax = plt.subplots(4,4,figsize = (16,16))
for i in range(0,4) :
    for j in range(0,4) :
        sns.countplot(df.select_dtypes(exclude=["number"]).iloc[:,4*i+j],ax = ax[i,j],palette = "muted")

# pipeline with scale / onehotencoder / with LR classfication as baseline model
from sklearn.preprocessing import OneHotEncoder,StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression


df_dummies = pd.get_dummies(df)

# train test split
from sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test = train_test_split(df_dummies,Churn,test_size = 0.25,random_state = 1)

# baseline model with Logistic Regression
from sklearn.model_selection import cross_val_score,KFold

cv =  KFold(10,random_state=1)
baseline = LogisticRegression(random_state = 1)
baseline.fit(x_train,y_train)
cv_bl = cross_val_score(baseline,x_test,y_test,cv =cv).mean()

#bl_pred = baseline.predict(x_test)
print("Baseline model accuracy is :",cv_bl) # 0.8048993506493506

_,ax = plt.subplots(4,4,figsize = (16,16))
for i in range(0,4) :
    for j in range(0,4) :
        sns.countplot(df.select_dtypes(exclude=["number"]).iloc[:,4*i+j],ax = ax[i,j],palette = "muted",hue = Churn,dodge = False)

_,ax = plt.subplots(3,1,figsize = (9,12))
for i,c in enumerate(df.select_dtypes([np.number]).columns) :
    # print(i,c)
    sns.boxplot(x = df[c],y = Churn,ax = ax[i],palette = "muted")

# short term
df["Short_term"] =  (df.TotalCharges == df.MonthlyCharges).astype('object')
sns.countplot(df["Short_term"],palette = "muted",hue = Churn,dodge = False)

# how many month they stay here
df["Month_Stay"] = df.TotalCharges/df.MonthlyCharges
sns.boxplot(y =df["Month_Stay"] ,x = Churn,palette = "muted")

df["long_contract_no_internet"] = ((df.Contract == "Two year") & (df.InternetService == "No")).astype("object")
sns.countplot(df["long_contract_no_internet"],palette = "muted",hue = Churn,dodge = False)

df = pd.get_dummies(df) # get k-1 dummies
x_train,x_test,y_train,y_test = train_test_split(df,Churn,test_size = 0.25,random_state = 1)

from sklearn.ensemble import GradientBoostingClassifier,RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
import lightgbm as lgb
from sklearn.neighbors import KNeighborsClassifier

# all algorithms I want to use
algorithms = pd.DataFrame({
    "Name" : ["Logistic Regression","Random Forest","GBM","DTree","LGBM","KNN"],
    "Algorithm" : [LogisticRegression(random_state=1),RandomForestClassifier(random_state = 1),
                   GradientBoostingClassifier(random_state=1),DecisionTreeClassifier(random_state=1),
                   lgb.LGBMClassifier(random_state=1),KNeighborsClassifier()]
})

# default score with default parameters
from sklearn.feature_selection import SelectKBest

score = []
for i in range(1,len(algorithms)+1) :
    clf = Pipeline([
        ("featureselection",SelectKBest(k = x_train.shape[1])),
        (algorithms.Name[i-1],algorithms.Algorithm[i-1])
    ])
    clf.fit(x_train,y_train)
    score.append(cross_val_score(clf,x_test,y_test,cv = cv).mean())
    #print("{} accuracy is {}:".format(algorithms.Name[i-1],(pred == y_test).mean()))
algorithms["Score"] = score
algorithms

# feature selection for LR
lr_score = []
for i in np.arange(0.5,1.5,0.2) :
    for j in range(20,x_train.shape[1]+1) :
        clf = Pipeline([
                ("featureselection",SelectKBest(k = j)),
                ("LR",LogisticRegression(random_state=1,C = i))])
        clf.fit(x_train,y_train)
        cvs = cross_val_score(clf,x_test,y_test,cv = cv).mean()
        lr_score.append(cvs)
        #print("Score is {} with C = {} and {} feature".format(cvs,i,j))
print("Best Score is {}".format(max(lr_score)))
# Score is 0.8157077922077922 with C = 1.3 and 31 feature

from sklearn.metrics import classification_report,confusion_matrix
clf_lr = Pipeline([
                ("featureselection",SelectKBest(k = 31)),
                ("LR",LogisticRegression(random_state=1,C = 1.3))])
pred = clf_lr.fit(x_train,y_train).predict(x_test)
print(classification_report(y_test,pred))
sns.heatmap(confusion_matrix(y_test,pred),annot=True,cmap = "PuBuGn")

# parameter tuning in GBM
# default value is 0.785000

from sklearn.model_selection import GridSearchCV
clf_pl = Pipeline([
                ("featureselection",SelectKBest(k = x_train.shape[1])),
                ("GBM",GradientBoostingClassifier(random_state=1))])
param = {
    "GBM__learning_rate" : np.arange(0.06,0.08,0.01),
    "GBM__n_estimators" : range(59,63,2),
    'GBM__max_depth':range(6,8,1),
    'GBM__min_samples_split':range(485,511,5),
    "GBM__subsample": [0.8]
}
clf_gbm = GridSearchCV(clf_pl,param,cv = cv,n_jobs = -1,verbose = 1)
clf_gbm.fit(x_train,y_train)
print(clf_gbm.best_params_)
print("-"*40)
print("Best Score is {}".format(clf_gbm.best_score_)) # 0.8103905953735305

gbm = GradientBoostingClassifier(random_state=1,learning_rate=0.07,max_depth=7,min_samples_split=495,n_estimators=59,subsample=0.8)
pred = gbm.fit(x_train,y_train).predict(x_test)
print(classification_report(y_test,pred))
sns.heatmap(confusion_matrix(y_test,pred),annot=True,cmap = "PuBuGn")

# 0.732091
clf_dt = Pipeline([
                ("featureselection",SelectKBest(k = x_train.shape[1])),
                ("DTree",DecisionTreeClassifier(random_state=1))])
param = {
    "DTree__criterion": ["gini","entropy"],
    "DTree__max_depth" :range(4,9),
    "DTree__min_samples_split":np.arange(0.1,0.6,0.1),
    "DTree__min_samples_leaf":np.arange(0.1,0.5,0.1),
    #"DTree__max_features " : ["auto","log2","sqrt"],
    "DTree__class_weight" : ["balanced",None]
}
clf_dt = GridSearchCV(clf_dt,param,cv = cv,n_jobs = -1,verbose = 1)
clf_dt.fit(x_train,y_train)
print(clf_dt.best_params_)
print("-"*40)
print("Best Score is {}".format(clf_dt.best_score_)) # 0.7897231702692453

import graphviz
from sklearn.tree import export_graphviz
dt = DecisionTreeClassifier(random_state=1,criterion="gini",max_depth=4,min_samples_leaf=0.1,min_samples_split=0.1)
dt.fit(x_train,y_train)
dot_data = export_graphviz(dt, out_file=None,
                         feature_names=x_train.columns,  
                         class_names=y_train,  
                         filled=True, rounded=True,  
                         special_characters=True)  
graph = graphviz.Source(dot_data)  
graph

Tuned_Score = [0.8157077922077922,0,0.8088737201365188,0.7897231702692453,0,0]
algorithms["Tuned Score"] = Tuned_Score
algorithms