HR analysis¶
Authors: Alexander Fred-Ojala, Ikhlaq Sidhu -- April 2019
In [1]:
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
pd.options.display.max_columns = 1000
%matplotlib inline
Read in candidate data¶
In [2]:
# read in all candidate data
df = pd.read_csv('data.csv')
Explore the data¶
In [3]:
# number of data entries
original_shape = df.shape
original_shape
Out[3]:
In [4]:
# explore columns
list(df.columns)
Out[4]:
In [126]:
# first entries
df.drop(['Full name','Employer'],axis=1).head(1)
Out[126]:
Handle missing values¶
If more than 70% of the data is missing from one column, then we remove that column from the data set.
In [6]:
# Number of missing values
df.isnull().sum()
Out[6]:
In [7]:
# remove all columns where more than 30% or more values are missing
for col in df.columns:
null_rate = df[col].isnull().sum()/df.shape[0]
if null_rate > .7:
df = df.drop(labels=col,axis=1)
In [8]:
# Number of dropped columns
original_shape[1] - df.shape[1]
Out[8]:
Columns kept in the analysis¶
In [9]:
df.columns
Out[9]:
Potential target / output column:¶
- Status
- Linked job step
- All linked jobs
- Last note
In [10]:
# Status
df['Status'].value_counts() # only if the candidate is active or not?
Out[10]:
In [11]:
df['Linked job step (not editable)'].value_counts() # offer accepted and successful placement
Out[11]:
In [12]:
df['All linked jobs (name & step)'].head()
Out[12]:
In [13]:
df['Last note'].value_counts()[:10]
Out[13]:
Chose Linked job step as predicted output of success¶
In [14]:
# check data types
df.dtypes
Out[14]:
Analyze the influence of work experience vs success¶
Histogram of the work experience distribution¶
In [15]:
work_exp = df['Total Years of Work Experience']
work_exp.dropna().astype(int).hist();
Create new data frame with only work experience and success / not¶
In [16]:
df_new = df[['Linked job step (not editable)','Total Years of Work Experience']]
Binary mapping of target variable¶
In [17]:
df_new['Linked job step (not editable)'] = df_new['Linked job step (not editable)'].map({'Offer Accepted - Successful Placement':1, 'Offer Accepted':0})
In [18]:
# Rename columns
df_new.columns = ['success','work_exp']
In [19]:
# drop missing values
df_new = df_new.dropna()
In [20]:
df_new.shape
Out[20]:
Correlation between variables¶
We can see significant positive correlation between work experience and Successful placement
In [22]:
import seaborn as sns
df_new.corr()
Out[22]:
Calculate prediction baseline¶
In [24]:
df_new['success'].value_counts()
Out[24]:
In [25]:
# Baseline
baseline = df_new['success'].value_counts()[0]/df_new.shape[0]
baseline
Out[25]:
The basline is 84%¶
Create Random Forest prediction model (with cross validation)¶
In [26]:
# Single model
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
x = np.array(df_new['work_exp']).reshape(-1, 1)
y = np.array(df_new['success'])
Accuracy¶
On average we get a 90% accuracy
In [40]:
model = RandomForestClassifier(n_estimators=50)
score = np.array([])
# Train 40 different models
n_runs = 40
for i in range(n_runs):
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = .2)
model.fit(x_train, y_train)
score = np.append(score, model.score(x_test, y_test))
print(np.sum(score) / n_runs)
In [37]:
# Standard deviation
np.std(score) # small standard deviation
Out[37]:
In [38]:
score
Out[38]:
Calculate relative improvement¶
Our model has a relative decrease in error of 45% (great for such a simple model, and within the margin of statistical relevancy!)
In [28]:
# Relative improvement over baseline
(1-score / n_runs)/(1-baseline)
Out[28]:
Check confusion matrix¶
This is great because it looks like false negatives (successful candidates that are predicted to not be good), are minimized.
In [41]:
from sklearn.metrics import confusion_matrix
pd.DataFrame(confusion_matrix(y_test, model.predict(x_test)),columns=['True negative','True positive'],\
index=['Predicted negative','Predicted positive'])
Out[41]:
Add additional features to the model to increase complexity and performance¶
Multiinput classifier
In [42]:
df.columns
Out[42]:
Two additional options:¶
- Candidate type
- Job assignment
In [44]:
# Number of missing values
df['Candidate Type'].isnull().sum()
Out[44]:
In [45]:
# Number of categories and samples / category
df['Candidate Type'].value_counts()
Out[45]:
In [46]:
# Number of missing values
df['Job Assignment'].isnull().sum()
Out[46]:
In [47]:
# Number of categories and samples / category
df['Job Assignment'].value_counts()
Out[47]:
Create new data frame with 3 features, 1 target¶
In [48]:
df3 = df[['Linked job step (not editable)',\
'Total Years of Work Experience','Candidate Type','Job Assignment']].copy()
df3.columns = ['success','work_exp','type','assignment']
In [49]:
df3['success'].unique()
Out[49]:
In [50]:
# Convert target variable to binary outputs
df3['success'] = df3['success'].replace({'Offer Accepted - Successful Placement':1, 'Offer Accepted':0})
In [51]:
# Drop missing values
df3 = df3.dropna()
In [52]:
df3['work_exp'] = df3['work_exp'].astype(int)
In [53]:
df3.dtypes
Out[53]:
In [54]:
df3.type.value_counts()
Out[54]:
In [55]:
# remove walk-in applicant category (too few samples)
df3 = df3[df3['type']!='Walk-in applicant'].copy()
In [56]:
df3.shape
Out[56]:
Convert nominal cateogries (type and assignment, to one hot encoded columns)¶
In [57]:
# get type and assignment as new columns
for col in ['type', 'assignment']:
new_entries = pd.get_dummies(df3[col])
df3[new_entries.columns] = new_entries
df3 = df3.drop(col, axis=1)
In [58]:
df3
Out[58]:
Check correlation heat map¶
In [59]:
sns.heatmap(df3.corr());
Train single model to check performance¶
In [114]:
# Single model
x = np.array(df3.loc[:, df3.columns != 'success'])
y = np.array(df3['success'])
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1)
Calculate baseline¶
We have to beat 95%
In [115]:
# baseline
df3['success'].value_counts()
Out[115]:
In [116]:
1-df3['success'].value_counts()[1]/df3.shape[0]
Out[116]:
Train classifier¶
In [117]:
model = RandomForestClassifier(n_estimators=10)
In [118]:
model.fit(x_train, y_train)
Out[118]:
Evaluate classifier¶
In [119]:
model.score(x_test, y_test)
Out[119]:
In [120]:
confusion_matrix(y_test, model.predict(x_test))
Out[120]:
Accuracy increased significantly over all runs (we get a lot of signal from this simple PoC model)¶
In [ ]: