Hr final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\"train.csv\")\n",
    "test_df = pd.read_csv(\"test.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = train_df.set_index(\"employee_id\")\n",
    "test_df = test_df.set_index('employee_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = train_df[\"previous_year_rating\"].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df[\"previous_year_rating\"] = test_df[\"previous_year_rating\"].fillna(mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df[\"previous_year_rating\"] = train_df[\"previous_year_rating\"].fillna(mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "most_frequent_category = train_df.groupby('education')['education'].count().sort_values(ascending=False).index[0]\n",
    "test_df['education'] = test_df['education'].fillna(most_frequent_category)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['education'] = train_df['education'].fillna(most_frequent_category)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_labels = train_df.groupby(['education'])['is_promoted'].mean().to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_df = train_df.groupby(['education'])['is_promoted'].mean()\n",
    "prob_df = pd.DataFrame(prob_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_df['Not promoted'] = 1-prob_df.is_promoted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_df['ratio'] = prob_df['is_promoted']/prob_df['Not promoted']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds_ratio_labels = prob_df['ratio'].to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['education'] = train_df.education.map(odds_ratio_labels)\n",
    "test_df['education'] = test_df.education.map(odds_ratio_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LabelEncoder()"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "le = LabelEncoder()\n",
    "le.fit(train_df['region'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df['region'] = le.transform(test_df['region'])\n",
    "train_df['region'] = le.transform(train_df['region'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "le.fit(train_df['department'])\n",
    "test_df['department'] = le.transform(test_df['department'])\n",
    "train_df['department'] = le.transform(train_df['department'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "le.fit(train_df['recruitment_channel'])\n",
    "test_df['recruitment_channel'] = le.transform(test_df['recruitment_channel'])\n",
    "train_df['recruitment_channel'] = le.transform(train_df['recruitment_channel'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "le.fit(train_df['gender'])\n",
    "test_df['gender'] = le.transform(test_df['gender'])\n",
    "train_df['gender'] = le.transform(train_df['gender'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = train_df.iloc[:, [0,1,2,3,4,5,6,7,8,9,10,11]].values\n",
    "y = train_df.iloc[:, -1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, \n",
    "                                                    random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X = sc.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_X = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gradient Boost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import GradientBoostingClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
       "                           learning_rate=0.3, loss='deviance', max_depth=3,\n",
       "                           max_features=None, max_leaf_nodes=None,\n",
       "                           min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                           min_samples_leaf=1, min_samples_split=2,\n",
       "                           min_weight_fraction_leaf=0.0, n_estimators=300,\n",
       "                           n_iter_no_change=None, presort='auto',\n",
       "                           random_state=2019, subsample=1.0, tol=0.0001,\n",
       "                           validation_fraction=0.1, verbose=0, warm_start=True)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gb = GradientBoostingClassifier(learning_rate=0.30,n_estimators=300,random_state= 2019, warm_start=True)\n",
    "gb.fit(train_X, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import (confusion_matrix, \n",
    "                             accuracy_score, \n",
    "                             precision_score, \n",
    "                             recall_score, \n",
    "                             f1_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = []\n",
    "acc = []\n",
    "precision = []\n",
    "recall = []\n",
    "f1 = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix for gb: \n",
      " [[10010    31]\n",
      " [  586   335]]\n",
      "Accuracy for gb: \n",
      " 0.9437146506112023\n",
      "Precision for gb: \n",
      " 0.9153005464480874\n",
      "Recall for gb: \n",
      " 0.36373507057546145\n",
      "f1_score for gb: \n",
      " 0.5205905205905206\n"
     ]
    }
   ],
   "source": [
    "print('Confusion Matrix for gb: \\n',confusion_matrix(y_test, gb.predict(test_X)))\n",
    "print('Accuracy for gb: \\n',accuracy_score(y_test, gb.predict(test_X)))\n",
    "acc.append(accuracy_score(y_test, gb.predict(test_X)))\n",
    "print('Precision for gb: \\n',precision_score(y_test, gb.predict(test_X)))\n",
    "precision.append(precision_score(y_test, gb.predict(test_X)))\n",
    "print('Recall for gb: \\n',recall_score(y_test, gb.predict(test_X)))\n",
    "recall.append(recall_score(y_test, gb.predict(test_X)))\n",
    "print('f1_score for gb: \\n',f1_score(y_test, gb.predict(test_X)))\n",
    "f1.append(f1_score(y_test, gb.predict(test_X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sub_X = test_df.iloc[:, [0,1,2,3,4,5,6,7,8,9,10,11]].values\n",
    "# sub_X = sc.transform(sub_X)\n",
    "# pred_y = gb.predict(sub_X)\n",
    "# test_df = pd.read_csv(\"test.csv\")\n",
    "# submission = pd.DataFrame({'employee_id':test_df['employee_id'],'is_promoted':pred_y})\n",
    "# filename = 'Hr analytics sol final.csv'\n",
    "# submission.to_csv(filename,index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgbc = xgb.XGBClassifier(learning_rate=0.30, random_state=2019, n_estimators=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "              colsample_bynode=1, colsample_bytree=1, gamma=0,\n",
       "              learning_rate=0.3, max_delta_step=0, max_depth=3,\n",
       "              min_child_weight=1, missing=None, n_estimators=500, n_jobs=1,\n",
       "              nthread=None, objective='binary:logistic', random_state=2019,\n",
       "              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n",
       "              silent=None, subsample=1, verbosity=1)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgbc.fit(train_X, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix for xgbc: \n",
      " [[10002    39]\n",
      " [  588   333]]\n",
      "Accuracy for xgbc: \n",
      " 0.9428024083196497\n",
      "Precision for xgbc: \n",
      " 0.8951612903225806\n",
      "Recall for xgbc: \n",
      " 0.36156351791530944\n",
      "f1_score for xgbc: \n",
      " 0.5150812064965197\n"
     ]
    }
   ],
   "source": [
    "print('Confusion Matrix for xgbc: \\n',confusion_matrix(y_test, xgbc.predict(test_X)))\n",
    "print('Accuracy for xgbc: \\n',accuracy_score(y_test, xgbc.predict(test_X)))\n",
    "acc.append(accuracy_score(y_test, xgbc.predict(test_X)))\n",
    "print('Precision for xgbc: \\n',precision_score(y_test, xgbc.predict(test_X)))\n",
    "precision.append(precision_score(y_test, xgbc.predict(test_X)))\n",
    "print('Recall for xgbc: \\n',recall_score(y_test, xgbc.predict(test_X)))\n",
    "recall.append(recall_score(y_test, xgbc.predict(test_X)))\n",
    "print('f1_score for xgbc: \\n',f1_score(y_test, xgbc.predict(test_X)))\n",
    "f1.append(f1_score(y_test, xgbc.predict(test_X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}