Customer Churn Prediction for Telecom Companies

Telecommunications service providers routinely analyze customer dissatisfaction, always tracking whether their customers are satisfied or not. These analyses are among the key metrics for retaining customers and acquiring new ones. Companies in this sector usually have customer service departments, and one of their main tasks is trying to win back lost customers, who can cost much more than new ones.

Because of this, companies invest in new technologies to carry out these analyses, commonly relying on the Churn rate, or simply Churn, one of the ways to measure customer attrition. Besides measuring this attrition rate, Churn analysis helps anticipate future cancellations, producing predictions that support decision-making and targeted actions for these customers. A familiar everyday example is streaming companies such as Spotify and Netflix.

Because it is such an important metric, Carlos Melo, in his Data Science na Prática course, gave us a challenge: implement a churn solution from scratch for a telecommunications company using real data. The data used in this project was originally made available on the IBM Developer learning platform. It represents a typical problem faced by telecom companies, and the full dataset can be found at this link.

The data provided by IBM doesn't come with explicit documentation, but fortunately the column names make the problem easy to understand, as we can see in the first five entries below, from a dataset of 7043 entries and 21 columns.

As the first step of any Data Science project, a good exploratory analysis is essential. So I ran the analyses I considered most important, starting with an assessment of the unique values.

This assessment showed that most of the columns in question have more than two categories, which means some processing is needed later on before feeding the model. Other checks were also necessary, such as identifying outliers, computing descriptive statistics, and checking for bias.

However, the descriptive statistics and the outlier check didn't reveal much. So I took a closer look at the Tenure column, which represents how long each customer has used the service and can indicate "service loyalty". I assumed that the time unit of Tenure is months.

Note that tenure drops from the first month onward, rises again in the last months (70 to 72), but otherwise the data looks fairly regular. Of all the checks mentioned above, I'll highlight the presence of bias, since the others didn't show anything that could compromise the model.

The bias analysis covered the gender, Partner and Churn columns. However, only the last one showed a problematic imbalance, so it had to be balanced, as you can see below:

As for the other columns, some of their unique values could be treated as the same thing, especially in the service columns. Even though this assumption is perfectly valid, in this work I'll keep them as separate values.

At this stage I performed some transformations to prepare the data for building a good model. First came the preprocessing, using LabelEncoder and get_dummies to convert the data into binary variables, putting each class in its own column with a distinct numeric value, as shown below:

With that, we can generate the correlation matrix of the data.

With all of this done, we can move on to the preprocessing and define our performance metric. For error estimation I used Cross-Validation, which I've already discussed in another article, combined with the recall metric to find the best model for this problem.

To make model evaluation easier, I defined a validation function:

#Função de validação

def valid(X, y, model, quite = False):

  X = np.array(X)
  y = np.array(y)
  pipeline = make_pipeline(StandardScaler(), model)
  scores = cross_val_score(pipeline, X, y, scoring="recall")

  if quite == False:
     print("Recall: {:.3f} (+/- {:.3f})".format(scores.mean(), scores.std()))

  return scores.mean()

It returns the recall value and the score. I then built a comparison baseline to serve as a reference for evaluating the models I used.

#Criando linha base
rfc = RandomForestClassifier()
score_baseline = valid(X_treino, y_treino, rfc)

This resulted in Recall: 0.485 (+/- 0.022). The balancing technique was based on Under Sampling, and, following recommendations from the literature, the data is standardized before applying it, and only on the training set.

Since I didn't know which model would perform best, I ran cross-validation for the following models:

• Random Forest
• Decision Trees
• Stochastic Gradient Descent
• SVC
• Logistic Regression
• LightGBM

I then instantiated and configured them as shown below:

#Instanciar os modelos
rc = RandomForestClassifier()
ad = DecisionTreeClassifier()
gde = SGDClassifier()
svc = SVC()
rl = LogisticRegression()
xgb = XGBClassifier()
lgbm = LGBMClassifier()

#Criar lista para resultados
modelo = []
recall = []

#Avaliar desempenho
for clf in (rc, ad, gde, svc, rl, xgb, lgbm):
  modelo.append(clf.__class__.__name__)
  recall.append(valid(X_treino_rus, y_treino_rus, clf, quite = True))

Recall = pd.DataFrame(data = recall, index=modelo, columns=["Recall"])

This produced the following results:

As the results show, XGBoost, Logistic Regression and SVC stood out, all with their default settings. So I took the best model from the previous step (XGBoost) and tuned its parameters to get the best possible result; you can find this in the full project.

After evaluating a few XGBoost configurations, I found the best result to be:

#Modelo Final
xgb=XGBClassifier(learning_rate=0.001,n_estimators=50,max_depth=1,min_child_weight=1,gamma=0.0)xgb.fit(X_treino_rus,y_treino_rus)

XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
              colsample_bynode=1, colsample_bytree=1, gamma=0.0,
              learning_rate=0.001, max_delta_step=0, max_depth=1,
              min_child_weight=1, missing=None, n_estimators=50, n_jobs=1,
              nthread=None, objective='binary:logistic', random_state=0,
              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
              silent=None, subsample=1, verbosity=1)

This gave the following prediction results:

              precision    recall  f1-score   support

           0       0.94      0.57      0.71      1316
           1       0.41      0.89      0.56       445

    accuracy                           0.65      1761
   macro avg       0.67      0.73      0.64      1761
weighted avg       0.80      0.65      0.67      1761

Área sobre a curva ASC: 0.7284109149277687

And the confusion matrix:

The result is an excellent model, with a true positive rate of 0.89 and a true negative rate of 0.57, and an AUC of 0.72.

In this project, we worked on a churn prediction problem whose main goal was to build a machine learning model capable of correctly identifying as many likely churners as possible. To get there, several steps were needed, such as balancing and standardization, and several models were tested to find the best result, finally arriving at an XGBoost model with an excellent result.