import pandas as pd
import numpy as np
import seaborn as sns
from matplotlib import pyplot as plt
%matplotlib inline
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import train_test_split # Scikit-Learn 0.18+
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import roc_curve
from sklearn.metrics import classification_report, accuracy_score
from sklearn.metrics import confusion_matrix

df = pd.read_csv('../Employee_retention/employee_data.csv')
df.head()

df.tail()

df.shape

df.info()

df.describe()

df.isnull().sum()

nullvalues = df.isnull().sum()
nullvalues.plot.barh()

# Plotting histogram for numeric distributions 
df.hist(figsize=(10,10), xrot = -45)
plt.show()

# # Plotting bar graphs for categorical distributions 
for feature in df.dtypes[df.dtypes == 'object'].index:
    sns.countplot(y=feature, data=df)
    plt.show()

# Just getting comfortable with matplotlib
df.hist('last_evaluation',bins=50);

# Just getting comfortable with matplotlib
df.plot(x='last_evaluation', y='avg_monthly_hrs',
        title='status', kind='scatter')

# jointplot showing the kde distributions of satisfication vs. tenure
sns.jointplot(x='tenure',y='satisfaction',data=df,color='red',kind='kde');

# Just getting comfortable with Seaborn
sns.countplot(y='n_projects', data = df)

correlations = df.corr()

plt.subplots(figsize=(7,5))
sns.heatmap(correlations)

mask = np.zeros_like(correlations)
mask[np.triu_indices_from(mask)] = True
plt.subplots(figsize=(10,5))
sns.axes_style("white")
sns.heatmap(correlations * 100, annot= True, mask=mask,
                 vmax=.3, square=True, cbar=False)

# Segment satisfaction by status
sns.violinplot(y = 'status', x = 'satisfaction', data = df)

# Segment last_evaluation by status
sns.violinplot(y = 'status', x = 'last_evaluation', data = df)

# Segment by status and display the means within each class
df.groupby('status').mean()

# Since target is status (categorical) will do extra segmentation
# Scatterplot of satisfaction vs. last_evaluation
sns.lmplot(x='satisfaction', y='last_evaluation', hue='status',
           data=df, fit_reg=False)

# # Scatterplot of satisfaction vs. last_evaluation, only those who have left
sns.lmplot(x='satisfaction', y='last_evaluation',
           data=df[df.status == 'Left'], fit_reg=False)

# Dropping duplicates
# Were only a few
df = df.drop_duplicates()
df.shape

# Looking at classes of department
list(df.department.unique())

# I will drop temporary workers 
df = df[df.department != 'temp']
df.shape

# unique values for filed_complaint
df.filed_complaint.unique()

df['filed_complaint'] = df.filed_complaint.fillna(0)

# check results 
df.filed_complaint.unique()

# unique values for recently promoted
df.recently_promoted.unique()

df['recently_promoted'] = df.recently_promoted.fillna(0)

# check results 
df.recently_promoted.unique()

# I will replace information technology with IT
df.department.replace('information_technology', 'IT',
                      inplace =True)

# plot results
sns.countplot(y = 'department', data = df)

df.isnull().sum()

# I will just replace nan values with missing for department
df['department'].fillna('Missing', inplace = True)

# create new  variable for missing last_evaluation
# astype converts 
df['last_evaluation_missing'] = df.last_evaluation.isnull().astype(int)

# Fill missing values with 0 for last evaluation
df.last_evaluation.fillna(0 , inplace = True)

#checking work
df.isnull().sum()

df.head()

# Looking Scatterplot of satisfaction vs. last_evaluation again
# for only those who have left
# To try and engineer
sns.lmplot(x='satisfaction', y='last_evaluation',
           data=df[df.status == 'Left'], fit_reg=False)

# I can engineer these findings 
df['underperformer'] = ((df.last_evaluation < 0.6) & 
                        (df.last_evaluation_missing == 0)).astype(int)
df['unhappy'] = (df.satisfaction < 0.2).astype(int)
df['overachiever'] = ((df.last_evaluation > 0.8) 
                     & (df.satisfaction > 0.7)).astype(int)

# The proportion of observations belonging to each group
df[['underperformer', 'unhappy', 'overachiever']].mean()

# Converting status into an indicator variable
# Left = 1
# Right = 0
df['status']= pd.get_dummies(df.status).Left

df['status'].unique()

df.status.head()

# Checking the proportion for who 'Left
df.status.mean()

# Create new dataframe with dummy features
df = pd.get_dummies(df, columns=['department', 'salary'])

# Display first 10 rows
df.head(5)

list(df.columns)

df.to_csv('engineered_cleaned', index = None)

df = pd.read_csv('../Employee_retention/engineered_cleaned')
unseen_data = pd.read_csv('../Employee_retention/unseen_raw_data.csv')

df.head()

unseen_data.head()

y = df.status
X = df.drop('status', axis = 1)

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size =0.2,
                                                    random_state = 1234 )

len(X_train), len(X_test), len(y_train), len(y_test)

ss = StandardScaler()
ss.fit(X_train)
X_train = ss.transform(X_train)
X_test = ss.transform(X_test)

# X_pred = ss.transform(X_pred)

lr = LogisticRegression()
lr.fit(X_train, y_train)

print(lr.score(X_test, y_test))

# Set up the parameters. Looking at C regularization strengths on a log scale.
lr_params = {
    'penalty':['l1','l2'],
    'solver':['liblinear'],
    'C':np.logspace(-5,0,100)
}

lr_gridsearch = GridSearchCV(LogisticRegression(), lr_params, cv=5, verbose=1)

%%time
lr_gridsearch = lr_gridsearch.fit(X_train, y_train)

# best score on the training data:
lr_gridsearch.best_score_

# best parameters on the training data:
# Lasso was chosen: this indicates that maybe unimportant (noise) variables
# is more of an issue in our data than multicollinearity.
lr_gridsearch.best_params_

# assign the best estimator to a variable:
best_lr = lr_gridsearch.best_estimator_

# Score it on the testing data:
best_lr.score(X_test, y_test)

# slightly better than the default.

coef_df = pd.DataFrame({
        'coef':best_lr.coef_[0],
        'feature':X.columns
    })

coef_df['abs_coef'] = np.abs(coef_df.coef)

# sort by absolute value of coefficient (magnitude)
coef_df.sort_values('abs_coef', ascending=False, inplace=True)

# Show non-zero coefs and predictors
coef_df[coef_df.coef != 0]

predictions = lr.predict(X_test)

accuracy_score(y_true = y_test, y_pred = predictions)

accuracy_score(y_true = y_test, y_pred = predictions, normalize=False)

print(classification_report(y_test,predictions))

rf = RandomForestClassifier()
rf.fit(X_train, y_train)

print(lr.score(X_test, y_test))

RandomForestClassifier().get_params()

rf_params = {
    'min_samples_split':[5],
    'max_depth':[3, 5, 7]
}

rf_gridsearch = GridSearchCV(RandomForestClassifier(), rf_params, cv=5, verbose=1)

%%time
rf_gridsearch = rf_gridsearch.fit(X_train, y_train)

rf_gridsearch.best_score_

rf_gridsearch.best_params_

best_rf = rf_gridsearch.best_estimator_

best_rf.score(X_test, y_test)

list(best_rf.feature_importances_)

# The feature importances (the higher, the more important the feature).
feat_import = list(best_rf.feature_importances_)

plt.plot(feat_import)
plt.ylabel('Feat_Importances')
plt.show()

#The number of features when fit is performed.
best_rf.n_features_

predictions = best_rf.predict(X_test)

print(classification_report(y_test,predictions))

confusion_matrix(y_true= y_test, y_pred = predictions)

best_rf.predict_proba(X_test)

y_hat = best_rf.predict(X_test)

cm = confusion_matrix(y_test, y_hat)
cm = pd.DataFrame(cm)

sns.heatmap(cm, annot=True)

# Much higher score with random forest 

gb = GradientBoostingClassifier()
gb.fit(X_train, y_train)

print(gb.score(X_test, y_test))

GradientBoostingClassifier().get_params()

gb_params = {
    'learning_rate':[0.05, 0.1,0.2],
    'n_estimators':[20,100,200],
    'max_depth':[1,3,5]
}

gb_gridsearch = GridSearchCV(RandomForestClassifier(), gb_params, cv=5, verbose=1)

%%time
gb_gridsearch = rf_gridsearch.fit(X_train, y_train)

# only a little better 
gb_gridsearch.best_score_

gb_gridsearch.best_params_

predictions = gb.predict(X_test)

accuracy_score(y_true = y_test, y_pred = predictions)

best_gb = lr_gridsearch.best_estimator_

best_gb.predict_proba(X_test)

confusion_matrix(y_true= y_test, y_pred = predictions)

print(classification_report(y_test,predictions))

y_hat = best_gb.predict(X_test)

cm = confusion_matrix(y_test, y_hat)
cm = pd.DataFrame(cm)

sns.heatmap(cm, annot=True)