models/all.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "## Importing Libraries"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn import tree, preprocessing\n",
    "from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split, KFold, cross_val_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.metrics import accuracy_score, precision_recall_fscore_support, classification_report\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import matplotlib.pyplot as plt\n",
    "import xgboost as xgb\n",
    "from joblib import dump, load"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Importing dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "outputs": [],
   "source": [
    "df_x = pd.read_csv(\"../dataframe/08/df_x.csv\")\n",
    "df_y = pd.read_csv(\"../dataframe/08/df_y.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Fixing NAN Values"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "outputs": [],
   "source": [
    "df_y[\"current experience\"] = df_y[\"current experience\"].fillna(\"\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Removing some records"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "conditions = (df_y[\"current experience\"] == \"\") | (df_y[\"current experience\"] == \"others\") | (df_y[\"current experience\"] == \"full stack developer\") | (df_y[\"current experience\"] == \"mobile developer\")\n",
    "\n",
    "indexes = df_y.loc[conditions].index\n",
    "df_y.drop(df_y[conditions].index, inplace=True)\n",
    "df_x.drop(indexes, inplace=True)\n",
    "df_y[\"current experience\"].unique()\n",
    "df_y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Normalizing datas"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "outputs": [],
   "source": [
    "columns_to_norm = [\n",
    "    \"bachelor-computer engineering\",\n",
    "    \"master-computer engineering\",\n",
    "    \"phd-computer engineering\",\n",
    "    \"other-majors\",\n",
    "    \"data scientist\",\n",
    "    \"ui-ux designer\",\n",
    "    \"network engineer\",\n",
    "    \"data engineer\",\n",
    "    \"software engineer\",\n",
    "    \"frontend developer\",\n",
    "    \"hardware engineer\",\n",
    "    \"devops engineer\",\n",
    "    \"database administrator\",\n",
    "]\n",
    "df_x[columns_to_norm] = df_x[columns_to_norm].apply(lambda x: (x - x.min()) / (x.max() - x.min()))\n",
    "df_x = df_x.fillna(\"\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Encoding Output Labels"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "le = LabelEncoder()\n",
    "train_x = df_x.iloc[:, 1:].values.tolist()\n",
    "train_y = df_y.values.ravel()\n",
    "train_y = le.fit_transform(train_y)\n",
    "\n",
    "np.shape(train_x), np.shape(train_y)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Train test split"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(train_x, train_y, shuffle=True, test_size=0.20, random_state=0)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Decision Tree Model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------- Decision Tree Classifier\n",
      "------ Decision Tree Classifier ------\n",
      "Model Score: 0.8253968253968254\n",
      "scores: [0.52380952 0.6031746  0.49206349 0.63492063 0.50793651]\n",
      "min: 0.49206349206349204\n",
      "max: 0.6349206349206349\n",
      "mean: 0.5523809523809524\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      0.778     0.700     0.737        10\n",
      "           1      0.778     0.875     0.824         8\n",
      "           2      0.625     1.000     0.769         5\n",
      "           3      0.750     0.562     0.643        16\n",
      "           4      1.000     1.000     1.000         5\n",
      "           5      0.800     0.667     0.727         6\n",
      "           6      0.875     0.700     0.778        10\n",
      "           7      0.579     0.733     0.647        15\n",
      "           8      1.000     1.000     1.000         4\n",
      "\n",
      "    accuracy                          0.747        79\n",
      "   macro avg      0.798     0.804     0.792        79\n",
      "weighted avg      0.764     0.747     0.746        79\n",
      "\n",
      "0: data engineer\n",
      "1: data scientist\n",
      "2: database administrator\n",
      "3: devops engineer\n",
      "4: frontend developer\n",
      "5: hardware engineer\n",
      "6: network engineer\n",
      "7: software engineer\n",
      "8: ui-ux designer\n"
     ]
    },
    {
     "data": {
      "text/plain": "['decision_tree.joblib']"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"-------- Decision Tree Classifier\")\n",
    "clf = tree.DecisionTreeClassifier(min_samples_split=5, min_samples_leaf=3)\n",
    "clf.fit(x_train, y_train)\n",
    "clf.score(x_train, y_train)\n",
    "print(\"------ Decision Tree Classifier ------\")\n",
    "print(f\"Model Score: {clf.score(x_train, y_train)}\")\n",
    "\n",
    "cv = KFold(n_splits=5, random_state=1, shuffle=True)\n",
    "scores = cross_val_score(clf, x_train, y_train, cv=cv)\n",
    "\n",
    "print(f\"scores: {scores}\\nmin: {np.min(scores)}\\nmax: {np.max(scores)}\\nmean: {np.mean(scores)}\")\n",
    "\n",
    "# Testing the model\n",
    "prediction = clf.predict(x_test)\n",
    "accuracy_score(y_test, prediction)\n",
    "print(classification_report(y_test, prediction, digits=3))\n",
    "\n",
    "t = [i for i in range(len(df_y[\"current experience\"].unique()))]\n",
    "for idx, val in enumerate(le.inverse_transform(t)):\n",
    "    print(f\"{idx}: {val}\")\n",
    "\n",
    "dump(clf, 'decision_tree.joblib')\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Visualize the tree"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(700, 350))\n",
    "_ = tree.plot_tree(clf, feature_names=list(df_x.iloc[:, 1:]), class_names=df_y[\"current experience\"].unique(),\n",
    "                   filled=True)\n",
    "fig.savefig(\"decision_tree.png\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Gradient Boosting"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(\"--------- Gradient Boosting Classifier ---------\")\n",
    "clf = GradientBoostingClassifier(n_estimators=310, learning_rate=0.1, max_depth=5, random_state=0, max_leaf_nodes=2)\n",
    "clf.fit(x_train, y_train)\n",
    "dump(clf, 'gradient_boosting.joblib')\n",
    "print(f\"Model Score: {clf.score(x_train, y_train)}\")\n",
    "\n",
    "cv = KFold(n_splits=5, random_state=1, shuffle=True)\n",
    "scores = cross_val_score(clf, x_train, y_train, cv=cv)\n",
    "\n",
    "print(f\"scores: {scores}\\nmin: {np.min(scores)}\\nmax: {np.max(scores)}\\nmean: {np.mean(scores)}\")\n",
    "\n",
    "# Testing the model\n",
    "prediction = clf.predict(x_test)\n",
    "accuracy_score(y_test, prediction)\n",
    "print(classification_report(y_test, prediction, digits=3))\n",
    "\n",
    "t = [i for i in range(len(df_y[\"current experience\"].unique()))]\n",
    "for idx, val in enumerate(le.inverse_transform(t)):\n",
    "    print(f\"{idx}: {val}\")\n",
    "\n",
    "print(\"probability of each class: \", clf.predict_proba(x_test))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## XGBOOST"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------- XGBoost ---------\n",
      "Model Score: 0.8952380952380953\n",
      "scores: [0.6031746  0.68253968 0.68253968 0.73015873 0.63492063]\n",
      "min: 0.6031746031746031\n",
      "max: 0.7301587301587301\n",
      "mean: 0.6666666666666666\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      0.800     0.800     0.800        10\n",
      "           1      1.000     0.875     0.933         8\n",
      "           2      0.714     1.000     0.833         5\n",
      "           3      0.917     0.688     0.786        16\n",
      "           4      1.000     0.800     0.889         5\n",
      "           5      0.714     0.833     0.769         6\n",
      "           6      1.000     0.500     0.667        10\n",
      "           7      0.619     0.867     0.722        15\n",
      "           8      0.667     1.000     0.800         4\n",
      "\n",
      "    accuracy                          0.785        79\n",
      "   macro avg      0.826     0.818     0.800        79\n",
      "weighted avg      0.829     0.785     0.784        79\n",
      "\n",
      "0: data engineer\n",
      "1: data scientist\n",
      "2: database administrator\n",
      "3: devops engineer\n",
      "4: frontend developer\n",
      "5: hardware engineer\n",
      "6: network engineer\n",
      "7: software engineer\n",
      "8: ui-ux designer\n"
     ]
    }
   ],
   "source": [
    "print(\"--------- XGBoost ---------\")\n",
    "xgb_classifier = xgb.XGBClassifier()\n",
    "xgb_classifier.fit(x_train, y_train)\n",
    "print(f\"Model Score: {clf.score(x_train, y_train)}\")\n",
    "\n",
    "cv = KFold(n_splits=5, random_state=0, shuffle=True)\n",
    "scores = cross_val_score(clf, x_train, y_train, cv=cv)\n",
    "\n",
    "print(f\"scores: {scores}\\nmin: {np.min(scores)}\\nmax: {np.max(scores)}\\nmean: {np.mean(scores)}\")\n",
    "\n",
    "# Testing the model\n",
    "prediction = clf.predict(x_test)\n",
    "accuracy_score(y_test, prediction)\n",
    "print(classification_report(y_test, prediction, digits=3))\n",
    "\n",
    "t = [i for i in range(len(df_y[\"current experience\"].unique()))]\n",
    "for idx, val in enumerate(le.inverse_transform(t)):\n",
    "    print(f\"{idx}: {val}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Logistic Regression"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scores: [0.47619048 0.57142857 0.38095238 0.76190476 0.61904762 0.42857143\n",
      " 0.61904762 0.66666667 0.42857143 0.61904762 0.71428571 0.61904762\n",
      " 0.71428571 0.57142857 0.38095238]\n",
      "min: 0.38095238095238093\n",
      "max: 0.7619047619047619\n",
      "mean: 0.5714285714285715\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      1.000     0.700     0.824        10\n",
      "           1      0.750     0.375     0.500         8\n",
      "           2      1.000     0.600     0.750         5\n",
      "           3      0.727     0.500     0.593        16\n",
      "           4      1.000     0.800     0.889         5\n",
      "           5      0.333     0.167     0.222         6\n",
      "           6      0.438     0.700     0.538        10\n",
      "           7      0.429     0.800     0.558        15\n",
      "           8      1.000     0.750     0.857         4\n",
      "\n",
      "    accuracy                          0.608        79\n",
      "   macro avg      0.742     0.599     0.637        79\n",
      "weighted avg      0.689     0.608     0.613        79\n",
      "\n",
      "0: data engineer\n",
      "1: data scientist\n",
      "2: database administrator\n",
      "3: devops engineer\n",
      "4: frontend developer\n",
      "5: hardware engineer\n",
      "6: network engineer\n",
      "7: software engineer\n",
      "8: ui-ux designer\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(random_state=0, max_iter=200, ).fit(x_train, y_train)\n",
    "clf.score(x_train, y_train)\n",
    "\n",
    "cv = KFold(n_splits=15, random_state=1, shuffle=True)\n",
    "scores = cross_val_score(clf, x_train, y_train, cv=cv)\n",
    "\n",
    "print(f\"scores: {scores}\\nmin: {np.min(scores)}\\nmax: {np.max(scores)}\\nmean: {np.mean(scores)}\")\n",
    "\n",
    "# Testing the model\n",
    "prediction = clf.predict(x_test)\n",
    "accuracy_score(y_test, prediction)\n",
    "print(classification_report(y_test, prediction, digits=3))\n",
    "\n",
    "t = [i for i in range(len(df_y[\"current experience\"].unique()))]\n",
    "for idx, val in enumerate(le.inverse_transform(t)):\n",
    "    print(f\"{idx}: {val}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Random Forest Classifier"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------- Random Forest Classifier ---------\n",
      "Model Score: 0.7492063492063492\n",
      "scores: [0.61904762 0.66666667 0.61904762 0.6031746  0.58730159]\n",
      "min: 0.5873015873015873\n",
      "max: 0.6666666666666666\n",
      "mean: 0.6190476190476191\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      0.857     0.600     0.706        10\n",
      "           1      0.750     0.750     0.750         8\n",
      "           2      1.000     1.000     1.000         5\n",
      "           3      1.000     0.438     0.609        16\n",
      "           4      1.000     0.400     0.571         5\n",
      "           5      0.833     0.833     0.833         6\n",
      "           6      0.667     0.600     0.632        10\n",
      "           7      0.452     0.933     0.609        15\n",
      "           8      1.000     1.000     1.000         4\n",
      "\n",
      "    accuracy                          0.696        79\n",
      "   macro avg      0.840     0.728     0.746        79\n",
      "weighted avg      0.798     0.696     0.697        79\n",
      "\n",
      "0: data engineer\n",
      "1: data scientist\n",
      "2: database administrator\n",
      "3: devops engineer\n",
      "4: frontend developer\n",
      "5: hardware engineer\n",
      "6: network engineer\n",
      "7: software engineer\n",
      "8: ui-ux designer\n"
     ]
    }
   ],
   "source": [
    "print(\"--------- Random Forest Classifier ---------\")\n",
    "clf = RandomForestClassifier(n_estimators=500, max_depth=5, min_samples_split=3)\n",
    "clf.fit(x_train, y_train)\n",
    "print(f\"Model Score: {clf.score(x_train, y_train)}\")\n",
    "\n",
    "cv = KFold(n_splits=5, random_state=1, shuffle=True)\n",
    "scores = cross_val_score(clf, x_train, y_train, cv=cv)\n",
    "\n",
    "print(f\"scores: {scores}\\nmin: {np.min(scores)}\\nmax: {np.max(scores)}\\nmean: {np.mean(scores)}\")\n",
    "\n",
    "# Testing the model\n",
    "prediction = clf.predict(x_test)\n",
    "accuracy_score(y_test, prediction)\n",
    "print(classification_report(y_test, prediction, digits=3))\n",
    "\n",
    "t = [i for i in range(len(df_y[\"current experience\"].unique()))]\n",
    "for idx, val in enumerate(le.inverse_transform(t)):\n",
    "    print(f\"{idx}: {val}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "df_x.loc[df_y[\"current experience\"] == \"software engineer\"]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "programming_languages = np.mean(df_x.loc[df_y[\"current experience\"] == \"software engineer\"].programming_languages)\n",
    "print(f\"programming: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].programming_languages)}\")\n",
    "print(f\"backend: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].backend_frameworks)}\")\n",
    "print(f\"devops: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].devops_technologies)}\")\n",
    "print(f\"front: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].frontend_frameworks)}\")\n",
    "print(f\"system design: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].system_design_skills)}\")\n",
    "print(f\"version control: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].version_controls)}\")\n",
    "print(f\"ui: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer']['ui-ux'])}\")\n",
    "print(f\"data related: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].data_related)}\")\n",
    "print(f\"databases: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].databases)}\")\n",
    "print(f\"ai models: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].ai_models)}\")\n",
    "print(f\"ai frameworks: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].ai_frameworks)}\")\n",
    "print(f\"network: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].network_skills)}\")\n",
    "print(f\"hardware: {np.mean(df_x.loc[df_y['current experience'] == 'software engineer'].hardware_skills)}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": true
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}