[PYTHON] [1 Kopie pro Tag] Vorhersage der Mitarbeiterabnutzung [Daily_Coding_001]

zunaechst

――Dieser Artikel ist ein Memorandum-Artikel für Grundschüler, die selbst Python, maschinelles Lernen usw. lernen. ――Es wird sehr einfach sein: "Studieren Sie, während Sie den Code kopieren, an dem Sie interessiert sind". ――Wir würden uns über Ihre konstruktiven Kommentare freuen (bitte LGTM & stock wenn Sie möchten).

Thema: Abrieb und Leistung von IBM HR Analytics-Mitarbeitern

――Das Thema lautet diesmal ** IBM HR Analytics Employee Attrition & Performance **. Nach der Erklärung in kaggle scheint es ein Problem zu sein, nach ** "Gründen für die Pensionierung von Mitarbeitern" ** zu suchen. ――Dieses Mal habe ich das Video kopiert, während ich das folgende Youtube-Video angesehen habe.

Link：Predict Employee Attrition Using Machine Learning & Python

Die Daten wurden von kaggle übernommen.

Link:IBM HR Analytics Employee Attrition & Performance

Bei der Analyse wurde Google Colaboratry verwendet, wie Sie im YouTube-Video sehen können (es ist eine günstige Zeit).

Schritt 1: Lesen Sie den Inhalt der Datenprüfung

Dann würde ich es gerne machen.

1.1: Bibliothek importieren

#Bibliothek laden
import numpy as np
import pandas as pd
import seaborn as sns

Laden Sie die zugrunde liegende Bibliothek. Es fühlt sich so an, als würden wir bei Bedarf weiterhin die erforderlichen Bibliotheken hinzufügen.

Laden Sie als Nächstes zum Laden von Daten die von der kaggle-Site heruntergeladene CSV-Datei mit Google Colab.

1.2: Hochladen von Dateien in Google Colab

#Daten hochladen
from google.colab import files
uploaded = files.upload()

Auf diese Weise können Sie lokal gespeicherte Dateien in Google Colab importieren. Normalerweise lade ich Dateien auf Google Drive hoch und lade sie dann in Verbindung mit Google Drive, damit dies einfacher und besser ist.

1.3: Laden mit Pandas

Ich werde die hochgeladenen Daten lesen.

#Daten lesen
df = pd.read_csv('WA_Fn-UseC_-HR-Employee-Attrition.csv')

#Bestätigung der Daten
df.head(7)

Es ist ein vertrauter Code. Von nun an werden wir den Inhalt der Daten überprüfen.

Bestätigung des Dateninhalts

Der folgende Code wird (tatsächlich) separat ausgeführt, aber ich werde sie hier zusammenstellen.

#Überprüfen Sie die Anzahl der Zeilen / Spalten im Datenrahmen
df.shape

#Überprüfen Sie den Datentyp des Inhalts jeder Spalte
df.dtypes

#Bestätigung fehlender Werte
df.isna().sum()
df.isnull().values.any()

#Bestätigung der Basisstatistik
df.describe()

#Bestätigung der Anzahl der Rentner und eingeschriebenen Personen (Verständnis der Anzahl der erklärten Variablen)
df['Attrition'].values_counts() #Abbildung 1

#Visualisierung von Rentnern und Einschreibung
sns.countplot(df['Attrition'])

#Visualisierung der Anzahl der Rentner und Einschreibungen nach Alter
import matplotlib.pyplot as plt
plt.subplots(figsize=(12,4))
sns.countplot(x='Age', hue='Attrition', data=df, palette='colorblind') #Figur 2

【Abbildung 1】

【Figur 2】

Bis zu diesem Punkt überprüfen wir die Daten, die wir immer tun. Zunächst halte ich es für notwendig, den Inhalt der Daten zu bestätigen.

1.4: Bestätigung des eindeutigen Wertes des Objekttyps

Überprüfen Sie als Nächstes den eindeutigen Wert der Objekttypspalte der zuvor überprüften Datentypen.

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. Zeile: Jede Spalte wird wiederholt in einer for-Schleife abgerufen
2. 2. Zeile: Bestimmen Sie, ob die abgerufene Spalte ein Objekttyp ist
3. Zeile 3: Name der Ausgabespalte + eindeutiger Wert für diese Spalte
4. 4. Zeile: Geben Sie die Nummer jedes eindeutigen Werts aus

1.5: Löschen Sie unnötige Zeilen

Entfernen Sie Spalten, deren Vorhersage mit .drop () nicht sinnvoll ist.

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

Dies ist selbsterklärend. Entfernen Sie von df alles, was kein Grund ist, sich zurückzuziehen.

1.6: Überprüfen der Korrelation zwischen Spalten

Ich denke, das ist auch ein vertrauter Prozess. Überprüfen Sie die Korrelation (Korrelation) zwischen jeder Spalte und visualisieren Sie heatmap.

df.corr()

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

Dieses Mal werden beim Erstellen der Heatmap die folgenden beiden angegeben.

Referenz: Erstellen einer Heatmap mit Seaborn

1.7: Kennzeichnung kategorialer (nicht numerischer) Daten mit 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])

Hier wird der LabelEncoder von sklearn verwendet, um die Objekttypdaten durch numerische Daten zu ersetzen ("Zeichendaten in diskrete Werte (0, 1, ...) konvertieren, bevor sie auf den Klassifizierer angewendet werden").

Ändern Sie nach dem Ersetzen die Reihenfolge der df-Spalten, um die Analyse zu vereinfachen.

#Alter in neue Spalte duplizieren
df['Age_Years'] = df['Age']

#Löschen Sie die Spalte Alter
df = df.drop('Age', axis=1)

Schritt 2: Analysieren Sie mit sklearn

Dies ist die eigentliche Produktion (ganz zu schweigen davon, dass die Vorverarbeitung wichtig ist).

#Teilen Sie df in erklärende Variablen und erklärte Variablen
X = df.iloc[:, 1:df.shape[1]].values
Y = df.iloc[:, 0].values

#Testdatengröße der Trainingsdaten und Lehrerdaten (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)

#Klassifizierung nach zufälligen Wäldern
from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0)
forest.fit(X_train, Y_train)

Schauen wir es uns von oben an.

--Verwenden Sie iloc [] , um die erklärenden und abhängigen Variablen zu trennen. --Split Trainingsdaten und Testdaten mit sklearns train_test_split. Die Argumente von train_test_split lauten wie folgt.

(Siehe: [Erstellen von Trainings- und Testdaten mit 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))

• Mit Ranfam Forest klassifizieren. Das Argument hier ist

n_estimators: Geben Sie die Anzahl der Bäume an (Standard ist 100). Kriterium: Geben Sie "Gini" oder "Entropie" an (Standard ist "Gini").

Trainieren Sie danach das Modell mit wood.fit (...).

Schauen wir uns die Genauigkeit an.

forest.score(X_train, Y_train)

Danach verwenden wir confusion_matrix (gemischte Matrix), um die Genauigkeit zu berechnen.

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)))

Obwohl dies einfach ist, wird es mit sklean zu einer binären Klassifizierungskopie.

Schließlich

Obwohl der Inhalt nicht so schwierig ist, habe ich festgestellt, dass es noch einige Teile gibt, die ich nicht verstehe, deshalb würde ich gerne weiter studieren.

das ist alles.