Uma Abordagem de Aprendizado de Máquina para Atributos e Desempenho de Funcionários da IBM

Prevendo o atrito de funcionários valiosos… ..

Navoneel Chakrabarty Blocked Desbloquear Seguir Seguindo 2 de janeiro

Em uma empresa de TI, existem muitas arquiteturas de funcionários disponíveis. Algumas empresas de TI ou em determinados departamentos ou certos níveis seguem a estrutura do programador principal , na qual existe uma organização “estrela” em torno de uma posição “principal” designada ao engenheiro que melhor entende os requisitos do sistema.

Arquitetura principal do programador

Enquanto, alguns seguem uma estrutura sem ego ( democrática ), onde todos os Engenheiros estão no mesmo nível designado para trabalhos diferentes, como Design Front-End, Codificação Back-End, Teste de Software, etc. Mas, esta arquitetura não é seguida por grandes ou Gigantes de Software Multi-Nacionais. Mas, apesar de tudo, esta é uma arquitetura muito bem-sucedida e favorável ao meio ambiente.

Arquitetura Egolesa (Democrática)

O terceiro tipo de arquitetura é a estrutura mista , que é a combinação dos dois tipos acima. Esta é a arquitetura mais seguida e muito comum entre os gigantes do software.

Arquitetura Controlada Mista

Da mesma forma, a International Business Machine Corporation (IBM) provavelmente segue estruturas sem emaranhados ou sem mistura . Portanto, para o Departamento de RH, uma responsabilidade importante é medir o desgaste dos funcionários em intervalos de tempo específicos. Os fatores dos quais o Atraso de Funcionário depende são:

  1. Idade do empregado
  2. Renda Mensal
  3. Ao longo do tempo
  4. Taxa mensal
  5. Distância de casa
  6. Anos na empresa

e assim por diante…

A IBM também disponibilizou publicamente suas Informações aos Funcionários, com a declaração do problema:

" Prever o Atrito dos Empregados, ou seja, haverá atrito dos funcionários ou não, tendo em conta os Detalhes do Empregado, ou seja, os fatores responsáveis pelo atrito"

O Dataset do funcionário é disponibilizado no Kaggle:

Atributo e desempenho de funcionários do IBM HR Analytics
Preveja o atrito de seus funcionários valiosos www.kaggle.com

Uma solução possível para resolver este problema é aplicando o Aprendizado de Máquina, isto é, transmitindo Inteligência de Máquina, que envolve o desenvolvimento de um Modelo Preditivo, treinando-o, usando os dados disponíveis e validando-o para a Análise de Desempenho do Modelo….

Dada a seguir é um procedimento passo a passo de Desenvolvimento de Modelo de Aprendizado de Máquina usando Python e Scikit-Learn Machine Learning Toolbox:

  1. Desenvolvimento de Modelo:
 # importando todas as bibliotecas 
import numpy como np
importar pandas como pd
import matplotlib.pyplot como plt
% matplotlib inline
importe pylab como pl
de sklearn.metrics import roc_curve, auc
 # carregando o conjunto de dados usando Pandas 
df = pd.read_csv ('WA_Fn-UseC_-HR-Employee-Attrition.csv')
df.head () # Saída mostrada abaixo

Saída do Dataframe do Pandas do Conjunto de Dados

 # verificar se o conjunto de dados contém algum valor ausente ... 
df.shape == df.dropna (). shape # Saída mostrada abaixo

Portanto, não há valores ausentes presentes no conjunto de dados.

Este é um problema de classificação binária, portanto, a distribuição de instâncias entre as duas classes é visualizada abaixo:

 y_bar = np.array ([df [df ['Atrito'] == 'Não']. forma [0] 
, df [df ['Attrition'] == 'Sim']. forma [0]])
x_bar = ['Não (0)', 'Sim (1)'
 # Bar Visualization 
plt.bar (x, y)
plt.xlabel ('Labels / Classes')
plt.ylabel ('Número de Instâncias')
plt.title ('Distribuição de etiquetas / classes no conjunto de dados')
# Saída mostrada abaixo

Visualização de Barras da Distribuição de Classe

 # Codificação de rótulo para dados categóricos / não numéricos 
X = df.iloc [:, [0] + lista (intervalo (2,35))]. Valores
y = df.iloc [:, 1] .valores
de sklearn.preprocessing import LabelEncoder, OneHotEncoder
 labelencoder_X_1 = LabelEncoder () 
X [: 1] = labelencoder_X_1.fit_transform (X [: 1])
X [:, 3] = labelencoder_X_1.fit_transform (X [:, 3])
X [:, 6] = labelencoder_X_1.fit_transform (X [:, 6])
X [:, 10] = labelencoder_X_1.fit_transform (X [:, 10])
X [:, 14] = labelencoder_X_1.fit_transform (X [:, 14])
X [: 16] = labelencoder_X_1.fit_transform (X [: 16])
X [: 20] = labelencoder_X_1.fit_transform (X [: 20])
X [:, 21] = labelencoder_X_1.fit_transform (X [:, 21])
y = labelencoder_X_1.fit_transform (y)
 Seleção de recurso usando o recurso Random Forest Classifier 
# Pontuações de importância
de sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier ()
model.fit (X, y) # Saída mostrada abaixo
 list_importances = list (model.feature_importances_) 
indices = sorted (intervalo (len (list_importances)), chave = lambda k
: list_importances [k])
feature_selected = [nenhum] * 34
k = 0
para i em reverso (índices):
se k <= 33:
feature_selected [k] = i
k = k + 1
X_selected = X [:, feature_selected [: 17]]
l_features = feature_selected
i = 0
para x em feature_selected:
l_features [i] = df.columns [x]
i = i + 1
l_features = np.array (l_features)
 # Extraindo 17 características mais importantes entre 34 recursos 
l_features [: 17] # Saída mostrada abaixo
 # Selecionando os 17 recursos mais importantes 
df_features = pd.DataFrame (X_selected, columns = ['Age',
'MonthlyIncome', 'OverTime',
'EmployeeNumber', 'MonthlyRate',
, 'DistanceFromHome', 'YearsAtCompany',
'TotalWorkingYears', 'DailyRate',
'HourlyRate', 'NumCompaniesWorked',
'JobInvolvement', 'PercentSalaryHike',
'StockOptionLevel',
'YearsWithCurrManager',
'Satisfação Ambiental',
'EducationField', 'Attrition']]
df_selected.head () # Saída mostrada abaixo

Assim, novamente, a codificação de rótulos deve ser feita para os recursos categóricos selecionados:

 # Codificação de etiqueta para recursos não numéricos selecionados: 
X = df_selected.iloc [:, list (range (0,17))]. Valores
y = df_selected.iloc [:, 17] .valores
 X [:, 2] = labelencoder_X_1.fit_transform (X [: 2]) 
X [: 16] = labelencoder_X_1.fit_transform (X [: 16])
y = labelencoder_X_1.fit_transform (y)

Agora as etapas de pré-processamento de dados acabaram. Vamos seguir para o Model Training:

 # 80-20 dividindo onde 80% dos dados são para o treinamento do modelo 
# e 20% Os dados são para validação e análise de desempenho

de 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 = 1753)
 # Usando Algoritmo de Regressão Logística para Treinamento de Modelos 
de sklearn.linear_model import LogisticRegression
clf = Regressão Logística (verbose = 3)
 # Treinando o modelo 
clf_trained = clf.fit (X_train, y_train) # Saída mostrada abaixo

Esta é a Estratégia de Otimização de Parâmetros da Biblioteca usada pela Regressão Logística

2. Análise de Desempenho do Modelo:

=> Precisão de treinamento

 clf_trained.score (X_train, y_train) # Saída mostrada abaixo 

Precisão de treinamento de 84,44% é alcançada pelo modelo

=> Precisão de Validação

 clf_trained.score (X_test, y_test) # Saída mostrada abaixo 

Validação A precisão de 89,12% é alcançada pelo modelo

=> Precisão , Recall e F1-Score

 # obtendo as previsões ... 
predictions = clf_trained.predict (X_test)
 print (classification_report (y_test, predictions)) 

Relatório de classificação do modelo

=> Matriz de Confusão

 # MÓDULO PARA MATRIZ DE CONFUSÃO 
 import matplotlib.pyplot como plt 
% matplotlib inline
import numpy como np
importar itertools
def plot_confusion_matrix (cm, classes,
normalize = Falso
title = 'Confusion matrix',
cmap = plt.cm.Blues):
"" "
Esta função imprime e plota a matriz de confusão.
A normalização pode ser aplicada configurando `normalize = True`.
"" "
se normalizar:
cm = cm.astype ('float') / cm.sum (axis = 1) [:, np.newaxis]
print ("matriz de confusão normalizada")
outro:
print ('Confusion matrix, without normalization')
 impressão (cm) 
 plt.imshow (cm, interpolação = 'mais próximo', cmap = cmap) 
plt.title (título)
plt.colorbar ()
tick_marks = np.arange (len (classes))
plt.xticks (tick_marks, classes, rotação = 45)
plt.yticks (tick_marks, classes)
 fmt = '.2f' se normalizar mais 'd' 
thresh = cm.max () / 2.
para i, j em itertools.product (range (cm.shape [0])
, intervalo (cm.shape [1])):
plt.text (j, i, formato (cm [i, j], fmt),
horizontalalignment = "center",
color = "white" se cm [i, j]> thresh else "preto")
 plt.tight_layout () 
plt.ylabel ('True label')
plt.xlabel ('rótulo previsto')
 # Gerando a matriz de confusão 
plt.figure ()
 cm = np.array ([[252, 1], [31, 10]]) 
 plot_confusion_matrix (confusion_matrix (y_test, predictions), 
classes = [0,1], normalize = verdadeiro
, title = 'Matriz de Confusão Normalizada')
# Saída mostrada abaixo

Matriz de Confusão Normalizada

=> Curva característica do operador do receptor:

 # Plotando a curva ROC 
y_roc = np.array (y_test)
fpr, tpr, thresholds = roc_curve (y_roc, função_função_de_função_de_contato (X_teste))
roc_auc = auc (fpr, tpr)
pl.clf ()
pl.plot (fpr, tpr, label = 'Curva ROC (área =% 0.2f)'% roc_auc)
pl.plot ([0, 1], [0, 1], 'k--')
pl.xlim ([0,0, 1,0])
pl.ylim ([0,0, 1,0])
pl.xlabel ('False Positive Rate')
pl.ylabel ('True Positive Rate')
pl.legend (loc = "inferior direito")
pl.show () # Saída mostrada abaixo

Curva Característica do Operador Receptor (Curva ROC)

De acordo com a Análise de Desempenho, pode-se concluir que o Modelo Preditivo de Aprendizado de Máquina foi bem-sucedido ao classificar corretamente 89.12% de exemplos desconhecidos (Conjunto de Validação) corretamente e mostrou números estatísticos bastante descendentes para diferentes métricas de desempenho.

Assim, deste modo, um Modelo Preditivo de Atração de Funcionários pode ser desenvolvido usando Análise de Dados e Aprendizado de Máquina.

Este modelo foi implementado em uma Aplicação Web por mim usando php ( PHP: Hypertext Preprocessor ) como back-end com a ajuda do PHP-ML . O link para o Web-App é dado abaixo:

IBM-HR-ANALYTICS
navocommerce.in

Para contatos pessoais sobre o artigo ou o Web-App ou discussões sobre o Machine Learning ou qualquer departamento de Data Science, sinta-se à vontade para entrar em contato comigo no LinkedIn .

Navoneel Chakrabarty – Fundador – Road To Financial Data Science | LinkedIn
Veja o perfil de Navoneel Chakrabarty no LinkedIn, a maior comunidade profissional do mundo. Navoneel tem 3 empregos listados… www.linkedin.com