[PYTHON] [1 copie par jour] Prédire l'attrition des employés [Daily_Coding_001]

en premier

Cet article est un article de mémoire destiné aux élèves du primaire qui étudient par eux-mêmes le python, l'apprentissage automatique, etc. «Ce sera extrêmement simple,« étudiez en copiant le code qui vous intéresse ». ――Nous apprécierions vos commentaires constructifs (veuillez LGTM & stock si vous le souhaitez)

Thème: Attrition et performance des employés IBM HR Analytics

―― Le thème cette fois est ** Attrition et performance des employés IBM HR Analytics **. Selon l'explication donnée dans kaggle, il semble y avoir un problème de recherche de ** «raisons de départ à la retraite des salariés» **. ―― Cette fois, j'ai copié la vidéo en regardant la vidéo YouTube suivante.

Link：Predict Employee Attrition Using Machine Learning & Python

Les données proviennent de kaggle.

Link:IBM HR Analytics Employee Attrition & Performance

L'analyse a utilisé Google Colaboratry, comme vous pouvez le voir dans la vidéo youtube (c'est un moment opportun).

Étape 1: Lire le contenu de la vérification des données

Alors j'aimerais le faire.

1.1: bibliothèque d'importation

#Charger la bibliothèque
import numpy as np
import pandas as pd
import seaborn as sns

Chargez la bibliothèque sous-jacente. Il semble que nous continuerons à ajouter les bibliothèques nécessaires au besoin.

Ensuite, concernant le chargement des données, chargez le fichier csv téléchargé depuis le site kaggle avec google colab.

1.2: Télécharger des fichiers sur Google Colab

#Télécharger des données
from google.colab import files
uploaded = files.upload()

En faisant cela, vous pouvez importer des fichiers stockés localement sur google colab. Je télécharge généralement des fichiers sur Google Drive, puis je les charge avec Google Drive, c'est donc plus facile et meilleur.

1.3: Chargement avec des pandas

Je vais lire les données téléchargées.

#Lire les données
df = pd.read_csv('WA_Fn-UseC_-HR-Employee-Attrition.csv')

#Confirmation des données
df.head(7)

C'est un code familier. Désormais, nous vérifierons le contenu des données.

Confirmation du contenu des données

Le code suivant est (en fait) exécuté séparément, mais je vais les rassembler ici.

#Vérifiez le nombre de lignes / colonnes dans le bloc de données
df.shape

#Vérifiez le type de données du contenu de chaque colonne
df.dtypes

#Confirmation des valeurs manquantes
df.isna().sum()
df.isnull().values.any()

#Confirmation des statistiques de base
df.describe()

#Confirmation du nombre de retraités et de personnes inscrites (Comprendre le nombre de variables expliquées)
df['Attrition'].values_counts() #Figure 1

#Visualisation des retraités et inscription
sns.countplot(df['Attrition'])

#Visualisation du nombre de retraités et des inscriptions par âge
import matplotlib.pyplot as plt
plt.subplots(figsize=(12,4))
sns.countplot(x='Age', hue='Attrition', data=df, palette='colorblind') #Figure 2

【Figure 1】

【Figure 2】

Jusqu'à présent, nous vérifions les données que nous faisons toujours. Tout d'abord, je pense qu'il est nécessaire de confirmer le contenu des données.

1.4: Confirmation de la valeur unique du type d'objet

Ensuite, vérifiez la valeur unique de la colonne de type d'objet des types de données que vous avez vérifiés précédemment.

for column in df.columns:
  if df[column].dtype == object:
    print(str(column) + ':' + str(df[column].unique()))
    print(df[column].value_counts())
    print('___________________________________________')

1. 1ère ligne: chaque colonne est récupérée à plusieurs reprises dans une boucle for
2. 2e ligne: déterminez si la colonne extraite est un type d'objet
3. Ligne 3: nom de la colonne de sortie + valeur unique pour cette colonne
4. 4ème ligne: affiche le numéro de chaque valeur unique

1.5: Supprimer les lignes inutiles

Supprimez les colonnes qui n'ont pas de sens à prédire avec .drop () .

df = df.drop('Over18', axis=1)
df = df.drop('EmployeeNumber', axis=1)
df = df.drop('StandardHours', axis=1)
df = df.drop('EmployeeCount', axis=1)

Ceci est explicite. Retirez du df tout ce qui n'est pas une raison de prendre sa retraite.

1.6: Vérifier la corrélation entre les colonnes

Je pense que c'est aussi un processus familier. Vérifiez la corrélation (corrélation) entre chaque colonne et visualisez heatmap.

df.corr()

plt.figure(figsize=(14, 14))
sns.heatmap(df.corr(), annot=True, fmt='.0%')

Cette fois, les deux suivants sont spécifiés lors de la création de la carte thermique.

Référence: Créer une carte thermique avec Seaborn

1.7: Étiquetage des données catégorielles (non numériques) avec sklearn

from sklearn.preprocessing import LabelEncoder

for column in df.columns:
    if df[columen].dtype == np.number:
        continue
    df[column] = LabelEncoder().fit_transform(df[column])

Ici, le LabelEncoder de sklearn est utilisé pour remplacer les données de type d'objet par des données numériques ("Convertir les données de caractères en valeurs discrètes (0, 1, ...) avant de les appliquer au classificateur").

Après le remplacement, modifiez l'ordre des colonnes df pour faciliter l'analyse.

#Dupliquer l'âge dans la nouvelle colonne
df['Age_Years'] = df['Age']

#Supprimer la colonne Âge
df = df.drop('Age', axis=1)

Étape 2: Analysez avec sklearn

Il s'agit de la production réelle (sans oublier que le prétraitement est important).

#Diviser df en variables explicatives et variables expliquées
X = df.iloc[:, 1:df.shape[1]].values
Y = df.iloc[:, 0].values

#Taille des données de test des données de formation et des données des enseignants (25)%)
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25, ramdom_state = 0)

#Classification par forêt aléatoire
from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0)
forest.fit(X_train, Y_train)

Regardons cela d'en haut.

--_ ʻiloc [] `_ est utilisé pour séparer les variables explicatives et dépendantes.

• Diviser les données d'entraînement et les données de test à l'aide de train_test_split de sklearn. Les arguments de train_test_split sont les suivants.

(Voir: [Créer des données d'entraînement et de test avec scikit-learn](https://pythondatascience.plavox.info/scikit-learn/%e3%83%88%e3%83%ac%e3%83%bc % e3% 83% 8b% e3% 83% b3% e3% 82% b0% e3% 83% 87% e3% 83% bc% e3% 82% bf% e3% 81% a8% e3% 83% 86% e3 % 82% b9% e3% 83% 88% e3% 83% 87% e3% 83% bc% e3% 82% bf))

--Classez en utilisant la forêt de Ranfam. L'argument ici est

n_estimators: spécifiez le nombre d'arbres (la valeur par défaut est 100) critère: spécifiez gini ou ʻentropy (la valeur par défaut est gini`)

Ensuite, entraînez le modèle avec forest.fit (...).

Regardons la précision.

forest.score(X_train, Y_train)

Après cela, ʻAccuracy est calculé en utilisant _confusion_matrix`_ (matrice mixte).

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(Y_test, forest.predict(X_test)) #cm: confusion_matrix

TN = cm[0][0]
TP = cm[1][1]
FN = cm[1][0]
FP = cm[0][1]

print(cm)
print('Model Testing Accuracy = {}'.format( (TP + TN) / (TP + TN + FN + FP)))

Avec ce qui précède, bien que ce soit facile, cela devient une copie de classification binaire utilisant sklean.

finalement

Bien que le contenu ne soit pas si difficile, j'ai réalisé qu'il y avait encore des parties que je ne comprenais pas, alors j'aimerais continuer à étudier.

c'est tout.