RandomForest_Complete.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RayNCode/code_collab/blob/main/RandomForest_Complete.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9j_xxAeoT3Gt"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.metrics import roc_auc_score, accuracy_score, precision_score, recall_score, f1_score\n",
        "import xgboost as xgb\n",
        "from xgboost import XGBClassifier\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split\n",
        "import sklearn\n",
        "sklearn.set_config(display=\"diagram\")\n",
        "from sklearn.compose import make_column_transformer\n",
        "from sklearn.preprocessing import OrdinalEncoder\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "from sklearn.pipeline import make_pipeline\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from itertools import combinations\n",
        "from sklearn.model_selection import cross_validate\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "from sklearn.metrics import ConfusionMatrixDisplay\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.experimental import enable_iterative_imputer\n",
        "from sklearn.impute import IterativeImputer\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "from sklearn.ensemble import RandomForestClassifier"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Data Preprocessing**"
      ],
      "metadata": {
        "id": "XPXlEG43UDjM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data_url = \"https://raw.githubusercontent.com/RayNCode/code_collab/main/project-3-files\"\n",
        "learn_dataset = pd.read_csv(f\"{data_url}/learn_dataset.csv\").copy()\n",
        "learn_dataset_Emp_contract = pd.read_csv(f\"{data_url}/learn_dataset_Emp_contract.csv\").copy()\n",
        "learn_dataset_sport = pd.read_csv(f\"{data_url}/learn_dataset_sport.csv\").copy()\n",
        "learn_dataset_job = pd.read_csv(f\"{data_url}/learn_dataset_job.csv\").copy()\n",
        "\n",
        "code_work_description_map = pd.read_csv(f\"{data_url}/code_work_description_map.csv\").copy()\n",
        "city_adm = pd.read_csv(f\"{data_url}/city_adm.csv\").copy()\n",
        "code_Club = pd.read_csv(f\"{data_url}/code_Club.csv\").copy()\n",
        "departments = pd.read_csv(f\"{data_url}/departments.csv\").copy()\n",
        "\n",
        "test_dataset_job = pd.read_csv(f\"{data_url}/test_dataset_job.csv\").copy()\n",
        "test_dataset = pd.read_csv(f\"{data_url}/test_dataset.csv\").copy()\n",
        "test_dataset_Emp_contract = pd.read_csv(f\"{data_url}/test_dataset_Emp_contract.csv\").copy()\n",
        "test_dataset_sport = pd.read_csv(f\"{data_url}/test_dataset_sport.csv\").copy()"
      ],
      "metadata": {
        "id": "qTc1EAsOT-Vb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_data_base(learn_dataset_job, work_desc, learn_dataset, dept_code, emp_contract, learn_dataset_sport, code_club, departments):\n",
        "    # Chargement et fusion des datasets de travail\n",
        "    merged_df = pd.merge(learn_dataset_job, work_desc, left_on='work_description', right_on='N3', how='left')\n",
        "\n",
        "    # Conversion des colonnes N2, N1 et N3 en chaînes de caractères\n",
        "    merged_df['N2'] = merged_df['N2'].astype(str)\n",
        "    merged_df['N1'] = merged_df['N1'].astype(str)\n",
        "    merged_df['N3'] = merged_df['N3'].astype(str)\n",
        "\n",
        "    # Remplir les valeurs manquantes\n",
        "    merged_df['N2'].fillna(merged_df['N3'].str[:-2], inplace=True)\n",
        "    merged_df['N1'].fillna(merged_df['N2'].str[:-1], inplace=True)\n",
        "\n",
        "    # Fusion avec d'autres datasets\n",
        "    data_2 = pd.merge(learn_dataset, merged_df, on=\"Id\", how=\"left\")\n",
        "    df_1 = data_2.merge(dept_code, on='insee_code')\n",
        "    df_2 = df_1.merge(emp_contract, on='Id', how='left')\n",
        "    df_3 = df_2.merge(learn_dataset_sport, on='Id', how='left')\n",
        "    df_4 = df_3.merge(code_Club, left_on='Club', right_on='Code', how='left')\n",
        "    final_df = df_4.merge(departments, on='dep', how='left')\n",
        "\n",
        "    # Conversion de type pour les colonnes 'Categorie' et 'REG'\n",
        "    final_df['Categorie'] = final_df['Categorie'].astype(str).astype('object')\n",
        "    final_df['REG'] = final_df['REG'].astype(str).astype('object')\n",
        "\n",
        "\n",
        "    # Création et application d'une condition pour filtrer et imputer des valeurs\n",
        "    condition = (final_df['ACTIVITY_TYPE'] != \"TYPE1|1\")\n",
        "    final_df.loc[condition, ['EMOLUMENT', 'Working_hours']] = 0.0\n",
        "    # Traitement des valeurs manquantes dans les colonnes catégorielles\n",
        "    categorical_columns = final_df.select_dtypes(include=['object']).columns\n",
        "    final_df[categorical_columns] = final_df[categorical_columns].fillna(\"None\")\n",
        "\n",
        "\n",
        "    return final_df"
      ],
      "metadata": {
        "id": "MbwOg2qGT-Xz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "learn_dataset_base = preprocess_data_base(learn_dataset_job, code_work_description_map, learn_dataset, city_adm, learn_dataset_Emp_contract, learn_dataset_sport, code_Club, departments)\n",
        "test_dataset_base = preprocess_data_base(test_dataset_job, code_work_description_map, test_dataset, city_adm, test_dataset_Emp_contract, test_dataset_sport, code_Club,departments)"
      ],
      "metadata": {
        "id": "BdVIo5oGT-aH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_learn_test(final_df): #ajouter l'ID quelque part\n",
        "    # Séparer la variable cible si elle est présente\n",
        "    if 'target' in final_df.columns:\n",
        "        y = final_df['target'].copy()\n",
        "        y = np.where(y == 'B', 1, 0)\n",
        "        X = final_df.drop(['target'], axis='columns')\n",
        "    else:\n",
        "        X = final_df.copy()\n",
        "        X_test_id = X['Id'].copy()\n",
        "\n",
        "    # Suppression des colonnes non nécessaires\n",
        "    X = X.drop([\"Id\", 'Nom de la commune', 'Nom fédération', 'Nom catégorie', 'Nom du département', 'Code'], axis=\"columns\")\n",
        "\n",
        "\n",
        "    # Imputation des valeurs manquantes - Ce n'est certainement pas la façon la plus efficiente de le faire. À voir si l'on change.\n",
        "    imputer = IterativeImputer(estimator=RandomForestRegressor(), max_iter=50, random_state=0)\n",
        "    columns_to_impute = ['Working_hours', 'EMOLUMENT']\n",
        "    X[columns_to_impute] = imputer.fit_transform(X[columns_to_impute])\n",
        "\n",
        "    # On devrait essayer avec XGB et voir les performances également.\n",
        "    # imputer = IterativeImputer(estimator=XGBRegressor(), max_iter=50, random_state=0)\n",
        "    # columns_to_impute = ['Working_hours', 'EMOLUMENT']\n",
        "    # X[columns_to_impute] = imputer.fit_transform(X[columns_to_impute])\n",
        "\n",
        "    if 'target' in final_df.columns:\n",
        "      return X, y\n",
        "    else:\n",
        "      return X, X_test_id"
      ],
      "metadata": {
        "id": "fdAXoDB6T-cb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X, y = preprocess_learn_test(learn_dataset_base)\n",
        "X_test, X_test_id = preprocess_learn_test(test_dataset_base)\n",
        "print(\"Shape de X_train:\", X.shape)\n",
        "print(\"Shape de y_test:\", y.shape)\n",
        "print(\"Shape de X_test:\", X_test.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MdubWTlTT-fI",
        "outputId": "f2854fe9-20eb-48ab-8ccd-c027ac20f549"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/impute/_iterative.py:785: ConvergenceWarning: [IterativeImputer] Early stopping criterion not reached.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape de X_train: (49993, 27)\n",
            "Shape de y_test: (49993,)\n",
            "Shape de X_test: (49992, 27)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/impute/_iterative.py:785: ConvergenceWarning: [IterativeImputer] Early stopping criterion not reached.\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, stratify=y)"
      ],
      "metadata": {
        "id": "Q1RZrJ7dT-gw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "preprocessing = make_column_transformer (\n",
        "    (OneHotEncoder(handle_unknown='ignore'), ['insee_code',\"is_student\", \"OCCUPATION_42\", \"ACTIVITY_TYPE\", \"household\", \"sex\", \"employer_category\", \"job_category\", \"Terms_of_emp\",\n",
        "                       \"Eco_sect\", \"Job_dep\", \"WORK_CONDITION\", \"work_description\",\"N3\", \"N2\", \"N1\", \"town_type\", \"dep\", \"Emp_contract\", \"Club\", \"Categorie\", 'REG']),\n",
        "    (OrdinalEncoder(), [\"Highest_degree\", \"EMPLOYEE_COUNT\"]),\n",
        "    remainder='passthrough')"
      ],
      "metadata": {
        "id": "duHz-BVCT-jQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Hyperparameter Tuning**"
      ],
      "metadata": {
        "id": "vOKoypNBWnfY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "param_grid = {\n",
        "    'random_forest__n_estimators': [50, 100, 200],\n",
        "    'random_forest__criterion': ['gini', 'entropy'],\n",
        "    'random_forest__max_depth': [None, 10, 20, 30],\n",
        "    'random_forest__min_samples_split': [2, 5, 10],\n",
        "    'random_forest__min_samples_leaf': [1, 2, 4],\n",
        "    'random_forest__max_features': ['auto', 'sqrt', 'log2', None],\n",
        "    'random_forest__max_leaf_nodes': [None, 10, 20, 30],\n",
        "    'random_forest__min_impurity_decrease': [0.0, 0.1, 0.2],\n",
        "    'random_forest__bootstrap': [True], #enabling bootstrap for our model and removing the false feature of the hyperparameter\n",
        "    'random_forest__oob_score': [True, False],\n",
        "    'random_forest__n_jobs': [None, -1, 1, 2],\n",
        "    }"
      ],
      "metadata": {
        "id": "tasZnSoST-lj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def tune_hyperparameters_rf(X_train, y_train):\n",
        "    random_forest = RandomForestClassifier(random_state=42)\n",
        "\n",
        "    pipeline = Pipeline(steps=[('preprocessing', preprocessing),\n",
        "                                ('random_forest', random_forest)])\n",
        "\n",
        "    cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)\n",
        "\n",
        "    # RandomizedSearchCV object\n",
        "    rf_grid = RandomizedSearchCV(\n",
        "        estimator=pipeline,\n",
        "        param_distributions=param_grid,\n",
        "        cv=cv,\n",
        "        scoring='accuracy',\n",
        "        n_iter=50,\n",
        "        n_jobs=-1,\n",
        "    )\n",
        "\n",
        "    rf_grid.fit(X_train, y_train)\n",
        "\n",
        "    print(\"Best hyperparameters:\\n\", rf_grid.best_params_)\n",
        "\n",
        "    return rf_grid.best_estimator_\n"
      ],
      "metadata": {
        "id": "JtIoBqXNT-nv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " rf_opt= tune_hyperparameters_rf(X_train, y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zxLo4EPXT-qS",
        "outputId": "f3380c0c-65f6-4a42-f951-0701f5be252a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best hyperparameters:\n",
            " {'random_forest__oob_score': True, 'random_forest__n_jobs': None, 'random_forest__n_estimators': 200, 'random_forest__min_samples_split': 2, 'random_forest__min_samples_leaf': 2, 'random_forest__min_impurity_decrease': 0.0, 'random_forest__max_leaf_nodes': None, 'random_forest__max_features': None, 'random_forest__max_depth': 30, 'random_forest__criterion': 'gini', 'random_forest__bootstrap': True}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "##Metrics Calculator for Random Forest\n",
        "def metrics_calculator(clf, X_test, y_test, model_name):\n",
        "    '''\n",
        "    This function calculates all desired performance metrics for a given model on test data.\n",
        "    '''\n",
        "    y_pred = clf.predict(X_test)\n",
        "    result = pd.DataFrame(data=[accuracy_score(y_test, y_pred),\n",
        "                                precision_score(y_test, y_pred, average='macro'),\n",
        "                                recall_score(y_test, y_pred, average='macro'),\n",
        "                                f1_score(y_test, y_pred, average='macro'),\n",
        "                                roc_auc_score(y_test, clf.predict_proba(X_test)[::,1], average='macro')],\n",
        "                          index=['Accuracy','Macro Precision','Macro Recall','Macro F1-score','Macro AUC'],\n",
        "                          columns = [model_name])\n",
        "\n",
        "    result = (result * 100).round(2).astype(str) + '%'\n",
        "    return result"
      ],
      "metadata": {
        "id": "90ncWigRT-st"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "##Evaluation Report for Random Forest\n",
        "def random_forest_evaluation(rf_opt, X_train, X_test, y_train, y_test, model_name):\n",
        "    '''\n",
        "    This function provides a complete report of the Random Forest model's performance\n",
        "    including classification reports and confusion matrix.\n",
        "    '''\n",
        "    # Set font scale\n",
        "    sns.set(font_scale=1.5)\n",
        "\n",
        "    # Generate classification report for training set\n",
        "    y_pred_train = rf_opt.predict(X_train)\n",
        "    print(\"\\n\\t  Classification report for training set\")\n",
        "    print(\"-\" * 55)\n",
        "    print(classification_report(y_train, y_pred_train))\n",
        "\n",
        "    # Generate classification report for test set\n",
        "    y_pred_test = rf_opt.predict(X_test)\n",
        "    print(\"\\n\\t   Classification report for test set\")\n",
        "    print(\"-\" * 55)\n",
        "    print(classification_report(y_test, y_pred_test))\n",
        "    print('\\n')\n",
        "\n",
        "    # Create figure and subplots\n",
        "    fig, (ax1, ax2) = plt.subplots(1, 2, dpi=90, figsize=(12, 5))\n",
        "\n",
        "    # Plot confusion matrix for test set\n",
        "    cmap = plt.cm.Purples\n",
        "    ConfusionMatrixDisplay.from_estimator(rf_opt, X_test, y_test, colorbar=False, cmap=cmap, ax=ax1)\n",
        "    ax1.set_title('Confusion Matrix for Test Data')\n",
        "    ax1.grid(False)\n",
        "\n",
        "    # Report desired results as a summary in the form of a table\n",
        "    result = metrics_calculator(rf_opt, X_test, y_test, model_name)\n",
        "    table = ax2.table(cellText=result.values, colLabels=result.columns, rowLabels=result.index, loc='center')\n",
        "    table.scale(0.6, 3.6)\n",
        "    table.set_fontsize(12)\n",
        "    ax2.axis('tight')\n",
        "    # Hide the axes\n",
        "    ax2.axis('off')\n",
        "    # set the title\n",
        "    ax2.set_title('{} Performance Summary on Test Data'.format(model_name), fontsize=18)\n",
        "    # Modify color\n",
        "    for key, cell in table.get_celld().items():\n",
        "        if key[0] == 0:\n",
        "            cell.set_color('purple')\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "dtAjgKCDT-vi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random_forest_evaluation(rf_opt, X_train, X_test, y_train, y_test, 'random_forest')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 887
        },
        "id": "wff-T7GKT-yJ",
        "outputId": "9614e7d8-4b06-46df-c4b8-49f57beeb928"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\t  Classification report for training set\n",
            "-------------------------------------------------------\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.97      0.95      0.96     15412\n",
            "           1       0.97      0.98      0.97     24582\n",
            "\n",
            "    accuracy                           0.97     39994\n",
            "   macro avg       0.97      0.96      0.97     39994\n",
            "weighted avg       0.97      0.97      0.97     39994\n",
            "\n",
            "\n",
            "\t   Classification report for test set\n",
            "-------------------------------------------------------\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.83      0.81      0.82      3853\n",
            "           1       0.88      0.90      0.89      6146\n",
            "\n",
            "    accuracy                           0.86      9999\n",
            "   macro avg       0.86      0.85      0.85      9999\n",
            "weighted avg       0.86      0.86      0.86      9999\n",
            "\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x450 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}