South Asian Wireless Telecom

 Churners in the Telecom Industry.

Laksara Abeysinghe

1. Aggregate of Total Revenue: The overall monthly revenue earned in Rupees by the carrier in the months August & September 2015.
2. Aggregate of SMS Revenue: The revenue earned through the SMS service used by the subscriber.
3. Aggregate of Data Revenue: The revenue earned through the Data service used by the subscriber.
4. Aggregate of Off Net Revenue: The revenue earned by the calls etc. made to the off-network (not the same network as the subscriber) customers by the carrier’s present subscriber.
5. Aggregate of On Net Revenue: The revenue earned by the calls etc. made to the on-network (on the same network as the subscriber) customers by the carrier’s present subscriber.
6. Network Age: The time passed since the subscriber started using the services of the carrier.
7. User Type: This detail helps in knowing if the user is subscribed to a 2G or 3G service.
8. Aggregate of Complaint Count: The number of complaints made by the subscribers.
9. Favorite Other Network: This information can certainly have a huge impact on churn ratio as it gives the information about which other network or operator the subscribers makes the most of the calls to and thus might influence the customer to move to that network to save money.
10. Aggregate of Data Volume: The volume of the data service used by the subscriber.
11. Aggregate Calls
12. Class: Whether the subscriber Churned or Active.

MCS: Multiple Classifier System to Predict the Churners in the Telecom Industry. Available from: https://www.researchgate.net/publication/320331663_MCS_Multiple_Classifier_System_to_Predict_the_Churners_in_the_Telecom_Industry [accessed Oct 12 2017].

Dataset From Kaggle website and https://www.kaggle.com/mahreen

In [1]:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import warnings

warnings.filterwarnings('ignore')

In [2]:

df = pd.read_csv('South Asian Wireless Telecom Operator (SATO 2015).csv')
df.head()

Out[2]:

	network_age	Aggregate_Total_Rev	Aggregate_SMS_Rev	Aggregate_Data_Rev	Aggregate_Data_Vol	Aggregate_Calls	Aggregate_ONNET_REV	Aggregate_OFFNET_REV	Aggregate_complaint_count	aug_user_type	sep_user_type	aug_fav_a	sep_fav_a	Class
0	1914	1592.7200	23.26	2.5	1.161130e+01	375	25523	99000	1	2G	2G	telenor	mobilink	Churned
1	2073	1404.1496	174.45	27.5	2.531725e+03	389	14584	77299	1	2G	2G	mobilink	ufone	Churned
2	3139	85.5504	14.34	5.0	2.913306e+04	15	477	4194	1	Other	Other	ptcl	telenor	Churned
3	139	2315.2292	19.25	52.5	2.674413e+05	636	50316	52400	2	2G	2G	telenor	ufone	Active
4	139	227.8620	2.95	42.5	1.461621e+06	17	2568	1701	1	NaN	NaN	mobilink	ufone	Active

In [3]:

df.shape

Out[3]:

(2000, 14)

In [4]:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2000 entries, 0 to 1999
Data columns (total 14 columns):
 #   Column                     Non-Null Count  Dtype  
---  ------                     --------------  -----  
 0   network_age                2000 non-null   int64  
 1   Aggregate_Total_Rev        2000 non-null   float64
 2   Aggregate_SMS_Rev          2000 non-null   float64
 3   Aggregate_Data_Rev         2000 non-null   float64
 4   Aggregate_Data_Vol         2000 non-null   float64
 5   Aggregate_Calls            2000 non-null   int64  
 6   Aggregate_ONNET_REV        2000 non-null   int64  
 7   Aggregate_OFFNET_REV       2000 non-null   int64  
 8   Aggregate_complaint_count  2000 non-null   int64  
 9   aug_user_type              1755 non-null   object 
 10  sep_user_type              1794 non-null   object 
 11  aug_fav_a                  1999 non-null   object 
 12  sep_fav_a                  1999 non-null   object 
 13  Class                      2000 non-null   object 
dtypes: float64(4), int64(5), object(5)
memory usage: 218.9+ KB

In [5]:

df.describe()

Out[5]:

	network_age	Aggregate_Total_Rev	Aggregate_SMS_Rev	Aggregate_Data_Rev	Aggregate_Data_Vol	Aggregate_Calls	Aggregate_ONNET_REV	Aggregate_OFFNET_REV	Aggregate_complaint_count
count	2000.000000	2000.000000	2000.000000	2000.000000	2.000000e+03	2000.000000	2000.000000	2000.000000	2000.000000
mean	1469.554500	905.020106	31.108605	58.806080	2.773961e+06	240.910500	7411.284500	16457.577500	1.924500
std	1286.753291	1151.308507	57.908418	247.459279	8.845272e+06	369.922258	16494.392836	34311.972061	2.265693
min	-8.000000	4.910000	0.000000	0.000000	5.860000e-02	1.000000	0.000000	0.000000	1.000000
25%	323.500000	247.149600	3.500000	1.250000	2.675567e+03	25.000000	114.000000	1432.000000	1.000000
50%	1194.500000	606.575000	14.810000	13.750000	1.822864e+05	99.000000	1940.500000	5039.000000	1.000000
75%	2247.250000	1220.045000	34.140000	53.750000	1.544505e+06	331.250000	7941.000000	15790.000000	2.000000
max	5451.000000	24438.830000	873.980000	8295.000000	1.550312e+08	5727.000000	381174.000000	431440.000000	49.000000

In [6]:

df.columns

Out[6]:

Index(['network_age', 'Aggregate_Total_Rev', 'Aggregate_SMS_Rev',
       'Aggregate_Data_Rev', 'Aggregate_Data_Vol', 'Aggregate_Calls',
       'Aggregate_ONNET_REV', 'Aggregate_OFFNET_REV',
       'Aggregate_complaint_count', 'aug_user_type', 'sep_user_type',
       'aug_fav_a', 'sep_fav_a', 'Class'],
      dtype='object')

In [7]:

df.isnull().sum()

Out[7]:

network_age                    0
Aggregate_Total_Rev            0
Aggregate_SMS_Rev              0
Aggregate_Data_Rev             0
Aggregate_Data_Vol             0
Aggregate_Calls                0
Aggregate_ONNET_REV            0
Aggregate_OFFNET_REV           0
Aggregate_complaint_count      0
aug_user_type                245
sep_user_type                206
aug_fav_a                      1
sep_fav_a                      1
Class                          0
dtype: int64

In [8]:

plt.figure(figsize=(16,3))
sns.heatmap(df.isnull(), cbar = False)

Out[8]:

<AxesSubplot:>

In [9]:

df['aug_fav_a'] = df['aug_fav_a'].fillna(df['aug_fav_a'].mode()[0])
df['sep_fav_a'] = df['sep_fav_a'].fillna(df['sep_fav_a'].mode()[0])

In [10]:

df.dropna(inplace=True)
df.shape

Out[10]:

(1722, 14)

EDA

In [11]:

plt.figure(figsize=(15,21))

plt.subplot(6,1,1),plt.scatter(x = df.Aggregate_Total_Rev, y = df.Aggregate_Data_Vol, color = 'red', edgecolors='black')
plt.title('Aggregate Total Revenue vs Aggregate Data Volume')
plt.ylabel('Data Volume')

plt.subplot(6,1,2),plt.scatter(x = df.Aggregate_Total_Rev, y = df.Aggregate_Data_Rev, color = 'yellow', edgecolors='black')
plt.title('Aggregate Total Revenue vs Aggregate Data Revenue')
plt.ylabel('Data Revenue')

plt.subplot(6,1,3),plt.scatter(x = df.Aggregate_Total_Rev, y = df.Aggregate_SMS_Rev, color = 'green', edgecolors='black')
plt.title('Aggregate Total Revenue vs Aggregate SMS Revenue')
plt.ylabel('SMS Revenue')

plt.subplot(6,1,4),plt.scatter(x = df.Aggregate_Total_Rev, y = df.Aggregate_Calls, color = 'cyan', edgecolors='black')
plt.title('Aggregate Total Revenue vs Aggregate_Calls')
plt.ylabel('Calls')

plt.subplot(6,1,5),plt.scatter(x = df.Aggregate_OFFNET_REV, y = df.Aggregate_ONNET_REV, color = 'pink', edgecolors='black')
plt.title('Aggregate Offnet Revenue vs Aggregate Onnet Revenue')

plt.subplot(6,1,6),plt.scatter(x = df.network_age, y = df.Aggregate_complaint_count, color = 'orange', edgecolors='black')
plt.title('Network Age vs Aggregate complaint count')
plt.ylabel('complaint_count')

plt.show()

Categorical Data Handling

In [12]:

(df['aug_user_type'].value_counts(), 
      df['sep_user_type'].value_counts())

Out[12]:

(3G       941
 2G       407
 Other    374
 Name: aug_user_type, dtype: int64,
 3G       966
 2G       382
 Other    374
 Name: sep_user_type, dtype: int64)

User type change in the both months was slightly different in 3G and 2G types.

In [13]:

sns.barplot(x = df['aug_user_type'].value_counts().index, y = df['aug_user_type'].value_counts().values, palette='viridis')
plt.show()

In [14]:

(df['aug_fav_a'].value_counts(), 
df['sep_fav_a'].value_counts())

Out[14]:

(ptcl        399
 ufone       388
 mobilink    248
 telenor     242
 zong        211
 warid       183
 0            51
 Name: aug_fav_a, dtype: int64,
 ufone       1059
 ptcl         351
 mobilink     123
 telenor       67
 warid         64
 zong          58
 Name: sep_fav_a, dtype: int64)

In [15]:

plt.figure(figsize=(16,8))
plt.subplot(1,2,1)
sns.barplot(x = df['aug_fav_a'].value_counts().index, y = df['aug_fav_a'].value_counts().values, palette='twilight')
plt.title('Favourite Other Networks of August Month')

plt.subplot(1,2,2)
sns.barplot(x = df['sep_fav_a'].value_counts().index, y = df['sep_fav_a'].value_counts().values, palette='viridis')
plt.title('Favourite Other Networks of September Month')

plt.show()

In [16]:

from sklearn.preprocessing import LabelEncoder
lable = LabelEncoder()
df['aug_user_type'] = lable.fit_transform(df['aug_user_type'])
df['sep_user_type'] = lable.fit_transform(df['sep_user_type'])
df['aug_fav_a'] = lable.fit_transform(df['aug_fav_a'])
df['sep_fav_a'] = lable.fit_transform(df['sep_fav_a'])
df['Class'] = lable.fit_transform(df['Class'])

df.head()

Out[16]:

	network_age	Aggregate_Total_Rev	Aggregate_SMS_Rev	Aggregate_Data_Rev	Aggregate_Data_Vol	Aggregate_Calls	Aggregate_ONNET_REV	Aggregate_OFFNET_REV	Aggregate_complaint_count	aug_user_type	sep_user_type	aug_fav_a	sep_fav_a	Class
0	1914	1592.7200	23.26	2.5	11.6113	375	25523	99000	1	0	0	3	0	1
1	2073	1404.1496	174.45	27.5	2531.7246	389	14584	77299	1	0	0	1	3	1
2	3139	85.5504	14.34	5.0	29133.0557	15	477	4194	1	2	2	2	2	1
3	139	2315.2292	19.25	52.5	267441.2813	636	50316	52400	2	0	0	3	3	0
5	143	973.9664	21.86	22.5	920871.0674	421	4032	15476	1	1	1	1	3	0

Splitting the dataset into response variable and other explanatory variables.

In [17]:

x = df.drop('Class', axis=1)
y = df['Class']

In [18]:

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=3)

Featuers Rescalling

In [19]:

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()

x_train = sc.fit_transform(x_train)
x_test = sc.fit_transform(x_test)

Training

In [20]:

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression, ridge_regression, Lasso
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier

In [21]:

from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import accuracy_score

In [22]:

models = []
models.append(('LD_Analysis', LinearDiscriminantAnalysis()))
models.append(('LR', LogisticRegression()))
models.append(('DT', DecisionTreeClassifier()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC()))
models.append(('RF', RandomForestClassifier()))
models.append(('Ada_Boost', AdaBoostClassifier()))
models.append(('GD_Boost', GradientBoostingClassifier()))

In [23]:

results = []
Names = []
res = []

for  name,model in models:
    Kfold = StratifiedKFold(n_splits=10, random_state=None)
    cv_res = cross_val_score(model, x_train, y_train, cv = Kfold, scoring='accuracy')
    results.append(cv_res)
    Names.append(name)
    res.append(cv_res.mean())
    print("%s: %f"% (name, cv_res.mean()))

LD_Analysis: 0.719713
LR: 0.728446
DT: 0.652867
KNN: 0.674733
NB: 0.673945
SVM: 0.719708
RF: 0.746562
Ada_Boost: 0.726991
GD_Boost: 0.750952

In [24]:

plt.figure(figsize=(14, 8))
sns.barplot(Names, res, palette="viridis")
plt.ylim(0.63,0.77)
plt.title('Accuracies of Various Algorithms')
plt.show()

So it can be selected the Gredient_boost Algorithm and Random Forest Classifier Algorithm for the further model training as the having better accuracy.

Gredient_Boost

In [27]:

Kfold = StratifiedKFold(n_splits=10)
GdBoost = GradientBoostingClassifier(
    loss='deviance',
    learning_rate=0.1,
    n_estimators=100,
    subsample=1.0,
    criterion='friedman_mse',
    min_samples_split=0.5,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_depth=9,
    min_impurity_decrease=0.0,
    init=None,
    random_state=None,
    max_features=None,
    verbose=0,
    max_leaf_nodes=None,
    warm_start=True,
    validation_fraction=0.1,
    n_iter_no_change=None,
    tol=0.001,
    ccp_alpha=0.0)
cv_res = cross_val_score(GdBoost, x_train, y_train, cv = Kfold, scoring='accuracy')
print(cv_res.mean())

0.7575161324447266

In [29]:

Kfold = StratifiedKFold(n_splits=5)
RamdomF = RandomForestClassifier(
    n_estimators=200,
    criterion='entropy',
    max_depth=None,
    min_samples_split=2,
    min_samples_leaf=1,
    min_weight_fraction_leaf=0.0,
    max_features='log2',
    max_leaf_nodes=None,
    min_impurity_decrease=0.0,
    bootstrap=True,
    oob_score=False,
    n_jobs=None,
    random_state=None,
    verbose=0,
    warm_start=False,
    class_weight=None,
    ccp_alpha=0.0,
    max_samples=None)
cv_res = cross_val_score(RamdomF, x_train, y_train, cv = Kfold, scoring='accuracy')
print(cv_res.mean())

0.7509143610013175

In [30]:

%%time

from sklearn.model_selection import RandomizedSearchCV

#Different RandomForestRegressor hyperparameters
rf_grid = {'n_estimators': np.arange(10,100,5),
          'max_depth': [3, 5, 10, 12, 15, 18],
          'min_samples_split':np.arange(2,20,1),
          'min_samples_leaf':np.arange(1,20,1),
          'max_features':[0.5,1,'log2','sqrt','auto'],
          'max_samples':[500, 750,1000, 1200],
          'criterion':['gini','entropy'],
          'bootstrap': [True, False],
          'bootstrap': [True, False]}

#Instantiate RandomizedSerachcCV model
rf_model = RandomizedSearchCV(RandomForestClassifier(n_jobs = -1),
                             param_distributions=rf_grid,
                             n_iter=4,
                             cv = 10,
                             verbose=True)

#fit the RandomizedSearchCV model
rf_model.fit(x_train, y_train)

Fitting 10 folds for each of 4 candidates, totalling 40 fits
CPU times: total: 2.94 s
Wall time: 7.94 s

Out[30]:

RandomizedSearchCV(cv=10, estimator=RandomForestClassifier(n_jobs=-1), n_iter=4,
                   param_distributions={'bootstrap': [True, False],
                                        'criterion': ['gini', 'entropy'],
                                        'max_depth': [3, 5, 10, 12, 15, 18],
                                        'max_features': [0.5, 1, 'log2', 'sqrt',
                                                         'auto'],
                                        'max_samples': [500, 750, 1000, 1200],
                                        'min_samples_leaf': array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19]),
                                        'min_samples_split': array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
       19]),
                                        'n_estimators': array([10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90,
       95])},
                   verbose=True)

In [31]:

#Evaluate the best parameters of RandomizedSerachCV model
rf_model.best_estimator_

Out[31]:

RandomForestClassifier(criterion='entropy', max_depth=5, max_features=1,
                       max_samples=500, min_samples_leaf=2,
                       min_samples_split=18, n_estimators=95, n_jobs=-1)

In [32]:

#Evaluate the RandomizedSerachCV model
rf_model.best_score_

Out[32]:

0.7320691843859093

In those model building it confirmed that instead using RandomizedSerachCV, we can get higher accuracy when using the algorithm as individually. when we were using Gredient Boosting, Random Forest we got (0.758, 0.751) accuracies respectavely.

If there are any mistakes when I was using in the parameter tuning and RandomizedSerachCV, Please inform me and it will be greatfull.

Thank You!