Prédire le churn des employés en Python

Par le passé, l’attention se portait surtout sur des « taux » comme le taux d’attrition et le taux de rétention. Les responsables RH calculaient les taux historiques et tentaient d’anticiper les taux futurs avec des outils de stockage et d’analyse de données. Ces indicateurs mesurent l’impact global du churn, mais ne racontent que la moitié de l’histoire. Une autre approche consiste à analyser, en plus de l’agrégé, les enregistrements individuels.

On trouve de nombreuses études de cas sur le churn client. Dans ce contexte, l’objectif est de prédire qui et quand un client cessera d’acheter. Le churn des employés est comparable, mais centré sur les collaborateurs. Ici, vous cherchez à prédire qui et quand un employé mettra fin à sa collaboration. Le churn des employés est coûteux, et de petites améliorations peuvent avoir un fort impact. Cela permet d’élaborer de meilleurs plans de rétention et d’améliorer la satisfaction des employés.

Analyse du churn des employés

Le churn des employés peut être défini comme la fuite ou le départ d’un actif intellectuel d’une entreprise ou d’une organisation. Plus simplement, lorsque des employés quittent l’organisation, on parle de churn. D’un point de vue populations, lorsqu’un individu quitte la population, on parle de churn.

La recherche montre que le churn des employés est influencé par l’âge, l’ancienneté, la rémunération, la satisfaction au travail, le salaire, les conditions de travail, le potentiel d’évolution et le sentiment d’équité. D’autres variables comme l’âge, le genre, l’origine, le niveau d’études et la situation matrimoniale jouent aussi un rôle. Certains profils rares sont plus difficiles à remplacer, ce qui affecte l’activité en cours et la productivité des équipes en place. Recruter un remplaçant a un coût (recrutement, formation), et il faut du temps pour atteindre le niveau d’expertise technique ou métier d’un collaborateur expérimenté. Les organisations s’attaquent à ce problème en appliquant des techniques d’apprentissage automatique pour prédire le churn, afin de prendre les mesures nécessaires.

Voici quelques points pour mieux comprendre le churn employé vs client :

• En entreprise, vous choisissez les employés que vous embauchez, alors qu’en marketing vous ne choisissez pas vos clients.

• Les employés sont le visage de votre entreprise et, collectivement, réalisent tout ce que votre entreprise produit.

• Perdre un client affecte le chiffre d’affaires et l’image de marque. Acquérir de nouveaux clients est plus difficile et coûteux que de retenir les clients existants. Le churn des employés est tout aussi douloureux pour les organisations : trouver et former un remplaçant demande du temps et des efforts.

Le churn des employés a des dynamiques propres par rapport au churn client. L’analyser aide à concevoir de meilleurs plans de rétention et à améliorer la satisfaction. Les algorithmes de data science permettent d’anticiper le churn futur.

Analyse exploratoire

L’analyse exploratoire des données est la phase initiale où l’on résume les caractéristiques des données (motifs, tendances, valeurs aberrantes) et où l’on teste des hypothèses grâce aux statistiques descriptives et à la visualisation.

Importer les modules

#import modules
import pandas  # for dataframes
import matplotlib.pyplot as plt # for plotting graphs
import seaborn as sns # for plotting graphs
% matplotlib inlinePropulsé par

Charger le jeu de données

Commençons par charger le jeu de données RH requis avec la fonction read_csv de pandas. Vous pouvez télécharger les données via ce lien.

data=pandas.read_csv('HR_comma_sep.csv')
Propulsé par

data.head()
Propulsé par

• Ici, les données d’origine sont séparées par une virgule (",") dans le jeu de données fourni.
• Pour un aperçu rapide, utilisez la fonction « head() » de pandas qui renvoie les cinq premières observations.
• De même, « tail() » renvoie les cinq dernières observations.
  
  

data.tail()
Propulsé par

Après avoir chargé le jeu de données, vous voudrez en savoir un peu plus. Consultez les noms d’attributs et types de données avec info().

data.info()
Propulsé par

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 14,999 entries, 0 to 14,998
Data columns (total 10 columns):
satisfaction_level       14999 non-null float64
last_evaluation          14999 non-null float64
number_project           14999 non-null int64
average_montly_hours     14999 non-null int64
time_spend_company       14999 non-null int64
Work_accident            14999 non-null int64
left                     14999 non-null int64
promotion_last_5years    14999 non-null int64
Departments              14999 non-null object
salary                   14999 non-null object
dtypes: float64(2), int64(6), object(2)
memory usage: 1.1+ MB
Propulsé par

• Ce jeu de données contient 14 999 échantillons et 10 attributs (6 entiers, 2 flottants et 2 objets).
• Aucune variable ne présente de valeurs nulles/manquantes.

Description détaillée des 10 attributs :

• satisfaction_level : point de satisfaction de l’employé, compris entre 0 et 1.
• last_evaluation : évaluation de performance par l’employeur, également entre 0 et 1.
• number_projects : nombre de projets attribués à un employé.
• average_monthly_hours : nombre moyen d’heures travaillées par mois.
• time_spent_company : ancienneté dans l’entreprise (nombre d’années).
• work_accident : l’employé a-t-il eu un accident du travail ou non.
• promotion_last_5years : l’employé a-t-il été promu au cours des 5 dernières années ou non.
• Departments : département/division de l’employé.
• Salary : niveau de salaire de l’employé (low, medium, high).
• left : l’employé a-t-il quitté l’entreprise ou non.

Passons aux insights

Dans ce jeu de données, vous avez deux types d’employés : ceux qui sont restés et ceux qui ont quitté l’entreprise. Vous pouvez donc scinder les données en deux groupes et comparer leurs caractéristiques. Calculez ensuite la moyenne des deux groupes avec groupby() et mean().

left = data.groupby('left')
left.mean()
Propulsé par

Interprétation : les employés qui ont quitté l’entreprise présentent un niveau de satisfaction plus faible, un taux de promotion plus bas, des salaires plus faibles et travaillent davantage que ceux qui sont restés.

La fonction describe() de pandas est pratique pour obtenir des statistiques récapitulatives. Elle renvoie le nombre de valeurs, la moyenne, l’écart type, les valeurs min et max, ainsi que les quantiles.

data.describe()
Propulsé par

Visualisation des données

Employés partis

Voyons combien d’employés sont partis.

Ici, vous pouvez tracer un diagramme en barres avec Matplotlib. Il est adapté pour afficher des effectifs de variables discrètes.

left_count=data.groupby('left').count()
plt.bar(left_count.index.values, left_count['satisfaction_level'])
plt.xlabel('Employés ayant quitté')
plt.ylabel("Nombre d'employés")
plt.show()
Propulsé par

data.left.value_counts()
Propulsé par

0    11428
1     3571
Name: left, dtype: int64
Propulsé par

On observe qu’environ 3 571 sur 15 000 sont partis, et 11 428 sont restés. Les départs représentent 23 % de l’effectif total.

Nombre de projets

De même, tracez un diagramme en barres pour compter le nombre d’employés selon le nombre de projets.

num_projects=data.groupby('number_project').count()
plt.bar(num_projects.index.values, num_projects['satisfaction_level'])
plt.xlabel('Nombre de projets')
plt.ylabel("Nombre d'employés")
plt.show()
Propulsé par

• La plupart des employés travaillent sur 3 à 5 projets.

Ancienneté dans l’entreprise

Tracez également un diagramme en barres du nombre d’employés par niveau d’ancienneté.

time_spent=data.groupby('time_spend_company').count()
plt.bar(time_spent.index.values, time_spent['satisfaction_level'])
plt.xlabel("Nombre d'années passées dans l'entreprise")
plt.ylabel("Nombre d'employés")
plt.show()
Propulsé par

La majorité des employés ont entre 2 et 4 ans d’expérience. On note aussi un écart marqué entre 3 et 4 ans d’ancienneté.

Sous-graphiques avec Seaborn

Analyser les variables une par une prend du temps. Mieux vaut utiliser la bibliothèque Seaborn et tracer tous les graphiques en une seule exécution grâce aux sous-graphiques.

features=['number_project','time_spend_company','Work_accident','left', 'promotion_last_5years','Departments ','salary']
fig=plt.subplots(figsize=(10,15))
for i, j in enumerate(features):
    plt.subplot(4, 2, i+1)
    plt.subplots_adjust(hspace = 1.0)
    sns.countplot(x=j,data = data)
    plt.xticks(rotation=90)
    plt.title("Nb. d'employés")
Propulsé par

On peut tirer les enseignements suivants de la visualisation ci-dessus :

• La plupart des employés travaillent sur 3 à 5 projets.
• On observe une forte chute entre 3 et 4 ans d’ancienneté.
• Les départs représentent 23 % de l’effectif total.
• Très peu d’employés ont été promus au cours des 5 dernières années.
• Le département Sales compte le plus d’employés, suivi des équipes techniques et du support.
• La plupart des employés perçoivent un salaire medium ou low.
  
  

fig=plt.subplots(figsize=(10,15))
for i, j in enumerate(features):
    plt.subplot(4, 2, i+1)
    plt.subplots_adjust(hspace = 1.0)
    sns.countplot(x=j,data = data, hue='left')
    plt.xticks(rotation=90)
    plt.title("Nb. d'employés")
Propulsé par

Ce que l’on observe :

• Les employés impliqués sur plus de 5 projets ont davantage quitté l’entreprise.
• Ceux qui ont travaillé sur 6 ou 7 projets sont souvent partis, probablement par surcharge de travail.
• Les employés avec 5 ans d’ancienneté partent plus, faute de promotions sur les 5 dernières années, tandis que ceux avec plus de 6 ans restent davantage, par attachement à l’entreprise.
• Ceux qui ont été promus au cours des 5 dernières années ne sont en général pas partis : parmi les partants, aucun n’avait été promu sur cette période.

Synthèse analyse et visualisation

Les facteurs suivants influencent le plus la décision de quitter l’entreprise :

• Promotions : les employés sont bien plus susceptibles de partir s’ils n’ont pas été promus au cours des 5 dernières années.
• Ancienneté : le cap des 3 ans semble constituer un point critique dans la carrière ; beaucoup partent autour de cette échéance. À 6 ans et plus, la probabilité de départ diminue nettement.
• Nombre de projets : l’engagement est clé. Les employés avec 3 à 5 projets quittent moins l’entreprise. Avec moins ou davantage de projets, le risque de départ augmente.
• Salaire : la plupart des départs surviennent parmi les groupes de salaire low ou medium.

Analyse de clusters

Identifions les groupes d’employés qui sont partis. Les facteurs essentiels pour rester ou partir sont la satisfaction et la performance. Regroupons-les via une analyse par clusters.

#import module
from sklearn.cluster import KMeans
# Filter data
left_emp =  data[['satisfaction_level', 'last_evaluation']][data.left == 1]
# Create groups using K-means clustering.
kmeans = KMeans(n_clusters = 3, random_state = 0).fit(left_emp)
Propulsé par

# Add new column "label" annd assign cluster labels.
left_emp['label'] = kmeans.labels_
# Draw scatter plot
plt.scatter(left_emp['satisfaction_level'], left_emp['last_evaluation'], c=left_emp['label'],cmap='Accent')
plt.xlabel('Satisfaction Level')
plt.ylabel('Last Evaluation')
plt.title('3 Clusters of employees who left')
plt.show()
Propulsé par

Ici, les employés partis se répartissent en 3 profils :

• Haute satisfaction et haute évaluation (zone verte) : des « gagnants ».
• Basse satisfaction et haute évaluation (zone bleue) : des « frustrés ».
• Satisfaction et évaluation modérées (zone grise) : un « mauvais appariement ».

Construire un modèle de prédiction

Prétraitement des données

De nombreux algorithmes d’apprentissage automatique exigent des données numériques ; il faut donc convertir les colonnes catégorielles en variables numériques.

Pour encoder, on peut par exemple mapper Salary ainsi : low : 0, medium : 1, high : 2.

Ce procédé s’appelle le label encoding, et sklearn le gère facilement via LabelEncoder.

# Import LabelEncoder
from sklearn import preprocessing
#creating labelEncoder
le = preprocessing.LabelEncoder()
# Converting string labels into numbers.
data['salary']=le.fit_transform(data['salary'])
data['Departments ']=le.fit_transform(data['Departments '])
Propulsé par

Ici, vous importez le module preprocessing et créez un objet LabelEncoder. Vous l’utilisez pour ajuster et transformer les colonnes "salary" et "Departments " en numériques.

Séparer apprentissage et test

Pour évaluer les performances du modèle, il est recommandé de diviser le jeu de données en ensemble d’entraînement et de test.

Utilisons train_test_split(). Vous devez passer 3 paramètres : caractéristiques, cible et taille de l’ensemble de test. Vous pouvez ajouter random_state pour un tirage reproductible.

#Spliting data into Feature and
X=data[['satisfaction_level', 'last_evaluation', 'number_project',
       'average_montly_hours', 'time_spend_company', 'Work_accident',
       'promotion_last_5years', 'Departments ', 'salary']]
y=data['left']
Propulsé par

# Import train_test_split function
from sklearn.model_selection import train_test_split

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)  # 70% training and 30% test
Propulsé par

Le jeu de données est scindé en deux parties selon un ratio de 70/30 : 70 % pour l’entraînement et 30 % pour le test.

Construction du modèle

Construisons un modèle de prédiction du churn des employés.

Nous allons utiliser un Gradient Boosting Classifier.

Commencez par importer le module GradientBoostingClassifier et créez l’objet de modèle avec GradientBoostingClassifier().

Entraînez le modèle sur l’ensemble d’apprentissage avec fit() puis prédisez sur l’ensemble de test avec predict().

#Import Gradient Boosting Classifier model
from sklearn.ensemble import GradientBoostingClassifier

#Create Gradient Boosting Classifier
gb = GradientBoostingClassifier()

#Train the model using the training sets
gb.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = gb.predict(X_test)
Propulsé par

Évaluer les performances du modèle

#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics
# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
# Model Precision
print("Precision:",metrics.precision_score(y_test, y_pred))
# Model Recall
print("Recall:",metrics.recall_score(y_test, y_pred))
Propulsé par

Accuracy: 0.971555555556
Precision: 0.958252427184
Recall: 0.920708955224
Propulsé par

Vous obtenez un taux de classification de 97 %, ce qui correspond à une excellente précision.

Précision (precision) : indique à quel point le modèle est précis lorsqu’il prédit un positif. Dans notre cas, lorsqu’il prédit qu’un employé va partir, cela s’avère correct dans 95 % des cas.

Rappel (recall) : parmi les employés partis présents dans l’ensemble de test, le modèle en identifie 92 %.

Conclusion

Félicitations, vous êtes arrivé au terme de ce tutoriel !

Vous avez découvert ce qu’est le churn des employés, en quoi il diffère du churn client, comment mener une analyse exploratoire et visualiser le jeu de données avec matplotlib et seaborn, puis comment construire et évaluer un modèle avec le package scikit-learn de Python.

Vos retours et questions sont les bienvenus. Laissez un commentaire : je ferai de mon mieux pour vous répondre.

Si vous souhaitez approfondir Python, découvrez le cours DataCamp Intermediate Python for Data Science.