From 23158b78f434b53fc932c40e2df9a40d32a60f6f Mon Sep 17 00:00:00 2001 From: Soumaya-JE <140071440+Soumaya-JE@users.noreply.github.com> Date: Wed, 7 Aug 2024 15:17:29 +0200 Subject: [PATCH] Delete notebooks/Mai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb --- ...ai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb | 551 ------------------ 1 file changed, 551 deletions(-) delete mode 100644 notebooks/Mai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb diff --git a/notebooks/Mai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb b/notebooks/Mai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb deleted file mode 100644 index 1dfe6c2d..00000000 --- a/notebooks/Mai24_CMLOPS_Accidents_Cdc__2_Modeles.ipynb +++ /dev/null @@ -1,551 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cf5908d4", - "metadata": { - "id": "cf5908d4" - }, - "source": [ - "# Mai24_CMLOPS_Accidents_Cdc_#2_Modeles" - ] - }, - { - "cell_type": "markdown", - "id": "12783600", - "metadata": { - "id": "12783600" - }, - "source": [ - "## 1- Analyse de corrélation de variables" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "74ec6fb5", - "metadata": { - "id": "74ec6fb5" - }, - "outputs": [], - "source": [ - "# Import des bibliothèques nécessaires au projet\n", - "import pandas as pd\n", - "import numpy as np\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import plotly.express as px\n", - "from plotly.offline import init_notebook_mode, iplot\n", - "import time\n", - "\n", - "# Ignorer les avertissements\n", - "warnings.filterwarnings(\"ignore\", category=pd.errors.DtypeWarning)\n", - "\n", - "from imblearn.over_sampling import SMOTE\n", - "from sklearn.model_selection import train_test_split\n", - "from imblearn.under_sampling import RandomUnderSampler\n", - "from imblearn.metrics import classification_report_imbalanced\n", - "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n", - "\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "import pickle" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d2e009b3", - "metadata": { - "id": "d2e009b3", - "outputId": "981de4c5-6c0f-404d-f9a7-e40dc3c67aef" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: imbalanced-learn in /home/souma/Downloads/yes/lib/python3.10/site-packages (0.12.3)\n", - "Requirement already satisfied: numpy>=1.17.3 in /home/souma/Downloads/yes/lib/python3.10/site-packages (from imbalanced-learn) (1.23.5)\n", - "Requirement already satisfied: scipy>=1.5.0 in /home/souma/Downloads/yes/lib/python3.10/site-packages (from imbalanced-learn) (1.12.0)\n", - "Requirement already satisfied: scikit-learn>=1.0.2 in /home/souma/Downloads/yes/lib/python3.10/site-packages (from imbalanced-learn) (1.4.2)\n", - "Requirement already satisfied: joblib>=1.1.1 in /home/souma/Downloads/yes/lib/python3.10/site-packages (from imbalanced-learn) (1.4.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/souma/Downloads/yes/lib/python3.10/site-packages (from imbalanced-learn) (3.5.0)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "pip install imbalanced-learn" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "9e1c7ce1", - "metadata": { - "id": "9e1c7ce1" - }, - "outputs": [], - "source": [ - "df = pd.read_csv('data 2005a2021.csv', index_col=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "49b0af3c", - "metadata": { - "id": "49b0af3c" - }, - "outputs": [], - "source": [ - "# colonne non catégorielle\n", - "colonne_Non_cat=['num_acc', 'an_nais', \"num_veh\", 'annee', 'mois', 'jour', 'com', 'dep', 'hr', 'mn','nbv','lartpc','larrout']\n", - "\n", - "# colonne catégorielle\n", - "cat_columns = [col for col in df.columns if col not in colonne_Non_cat]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3327530c", - "metadata": { - "id": "3327530c", - "outputId": "59fbceaf-7231-40a8-d0ed-95747a744246" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi2 avec 'grav':\n", - "{'lum': 42586.40576514557, 'agg': 89242.82155143883, 'int': 27733.507655346883, 'atm': 5963.580587186945, 'col': 93221.16170445719, 'catv': 102733.36800586228, 'choc': 49738.91297649023, 'manv': 101043.66215875177, 'place': 38465.963033061285, 'catu': 38293.87715526149, 'grav': 4357946.0, 'sexe': 2682.426360463483, 'trajet': 34449.21679522872, 'catr': 102264.44538582121, 'circ': 36994.1938459717, 'prof': 15249.309644481145, 'plan': 36547.93186768001, 'surf': 3357.507010418821, 'situ': 47764.423170739945}\n" - ] - } - ], - "source": [ - "import scipy.stats as stats\n", - "\n", - "# calcul des corrélations pour les variables catégorielles uniquement\n", - "cat_corr = {}\n", - "for col in cat_columns:\n", - " contingency_table = pd.crosstab(df['grav'], df[col])\n", - " chi2, p, dof, ex = stats.chi2_contingency(contingency_table)\n", - " cat_corr[col] = chi2\n", - "\n", - "print(\"Chi2 avec 'grav':\")\n", - "print(cat_corr)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "69807ff9", - "metadata": { - "id": "69807ff9", - "outputId": "352d2cc7-4beb-4458-aeb4-274145cea69c" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# bar plot pour les résultats du test du chi-carré\n", - "cat_corr_series = pd.Series(cat_corr).sort_values(ascending=False)\n", - "cat_corr_series.plot(kind='bar')\n", - "plt.title(\"Chi2 des variables catégorielles avec 'grav'\")\n", - "plt.ylabel('Chi2 Value')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a72fbeea", - "metadata": { - "id": "a72fbeea" - }, - "outputs": [], - "source": [ - "# le nombre de colonnes étant conséquent, nous cherchons à supprimer celles non nécessaires\n", - "# les variables atm, annee_y, annee_x, sexe et surf ne semblent pas corrélées avec grav - nous les supprimons donc\n", - "colonnes_a_supprimer = ['atm', 'annee', 'sexe', 'surf', \"num_veh\"]\n", - "df = df.drop(columns=colonnes_a_supprimer)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "0a56ac5b", - "metadata": { - "id": "0a56ac5b", - "outputId": "49c4668d-e58d-4f0f-a68a-1d3d94c7dd6e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Index: 2178973 entries, 200500000001 to 201900058840\n", - "Data columns (total 26 columns):\n", - " # Column Dtype \n", - "--- ------ ----- \n", - " 0 mois int64 \n", - " 1 jour int64 \n", - " 2 lum int64 \n", - " 3 agg int64 \n", - " 4 int int64 \n", - " 5 col float64\n", - " 6 com int64 \n", - " 7 dep int64 \n", - " 8 hr int64 \n", - " 9 mn int64 \n", - " 10 catv int64 \n", - " 11 choc float64\n", - " 12 manv float64\n", - " 13 place int64 \n", - " 14 catu int64 \n", - " 15 grav int64 \n", - " 16 trajet float64\n", - " 17 an_nais int64 \n", - " 18 catr int64 \n", - " 19 circ float64\n", - " 20 nbv int64 \n", - " 21 prof float64\n", - " 22 plan float64\n", - " 23 lartpc int64 \n", - " 24 larrout int64 \n", - " 25 situ float64\n", - "dtypes: float64(8), int64(18)\n", - "memory usage: 448.9 MB\n" - ] - } - ], - "source": [ - "df.info()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a8e4ad4f-eceb-49ab-ad5e-773e73ac80f1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2178973" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(df)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d921bad1-6568-430b-9fbc-aa3edad27c88", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "grav\n", - "1 1669817\n", - "3 450462\n", - "2 58694\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df[\"grav\"].value_counts()" - ] - }, - { - "cell_type": "markdown", - "id": "1949451c", - "metadata": { - "id": "1949451c" - }, - "source": [ - "## 2- Préparation du jeu de donnée - pré processing" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "3c11b197", - "metadata": { - "id": "3c11b197" - }, - "outputs": [], - "source": [ - "# on sépare les variables cibles et les caractéristiques\n", - "X = df.drop(columns=['grav'])\n", - "y = df['grav']" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "046bca47", - "metadata": { - "id": "046bca47" - }, - "outputs": [], - "source": [ - "# on divise les données en ensemble d'entraînement et de test\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "682fb5fe", - "metadata": { - "id": "682fb5fe" - }, - "outputs": [], - "source": [ - "# nous avons vu dans notre analyse de données que les classes 2 et 3 étaient sous représentées\n", - "\n", - "# afin de régler ce déséquilibre de classe, nous allons faire un SMOTE et l'appliquer à nos données\n", - "#smote = SMOTE(random_state=42)\n", - "#X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "7cffeea7-c04e-4b1b-ae39-d95763b441a1", - "metadata": {}, - "outputs": [], - "source": [ - "#print('Classes échantillon smote :', dict(pd.Series(y_train_resampled).value_counts()))\n", - "#le nombre de l'échantillon a augmenté (environ 4M)\n", - "#Classes échantillon smote : {1: 1335601, 3: 1335601, 2: 1335601}\n", - "#il vaut mieux utiliserla méthode de RandomUnderSampler" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "fad82d10-87ca-483a-8ffb-85ac46e3c58f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Classes échantillon undersampled : {1: 46839, 2: 46839, 3: 46839}\n" - ] - } - ], - "source": [ - "ru =RandomUnderSampler()\n", - "X_train_resampled, y_train_resampled = ru.fit_resample(X_train, y_train)\n", - "print('Classes échantillon undersampled :', dict(pd.Series(y_train_resampled).value_counts()))" - ] - }, - { - "cell_type": "markdown", - "id": "8aecee3e", - "metadata": { - "id": "8aecee3e" - }, - "source": [ - "## 3- Entrainement de plusieurs modèles" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "e1243f0f", - "metadata": { - "id": "e1243f0f", - "outputId": "44a02a21-f731-4de9-c552-f60c98581a95" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Temps d'entraînement du modèle : 0.72 secondes\n", - "Confusion Matrix:\n", - "[[229890 36627 67699]\n", - " [ 1431 7711 2713]\n", - " [ 20770 30338 38616]]\n", - "\n", - "Classification Report:\n", - " precision recall f1-score support\n", - "\n", - " 1 0.91 0.69 0.78 334216\n", - " 2 0.10 0.65 0.18 11855\n", - " 3 0.35 0.43 0.39 89724\n", - "\n", - " accuracy 0.63 435795\n", - " macro avg 0.46 0.59 0.45 435795\n", - "weighted avg 0.78 0.63 0.69 435795\n", - "\n", - "\n", - "Accuracy Score:\n", - "0.6338232425796533\n" - ] - } - ], - "source": [ - "# entrainement d un arbre de decision\n", - "\n", - "model_tree_clf = DecisionTreeClassifier(random_state=42, max_depth=10)\n", - "\n", - "start_time = time.time()\n", - "model_tree_clf.fit(X_train_resampled, y_train_resampled)\n", - "end_time = time.time()\n", - "\n", - "training_time = end_time - start_time\n", - "print(f\"Temps d'entraînement du modèle : {training_time:.2f} secondes\")\n", - "\n", - "y_pred = model_tree_clf.predict(X_test)\n", - "\n", - "print(\"Confusion Matrix:\")\n", - "print(confusion_matrix(y_test, y_pred))\n", - "\n", - "print(\"\\nClassification Report:\")\n", - "print(classification_report(y_test, y_pred))\n", - "\n", - "print(\"\\nAccuracy Score:\")\n", - "print(accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "dccaf5ff", - "metadata": { - "id": "dccaf5ff", - "outputId": "c7ca66f8-f037-4218-a1d6-af1708017b5a" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Temps d'entraînement du modèle : 28.86 secondes\n", - "Confusion Matrix:\n", - "[[234242 34413 65561]\n", - " [ 962 8304 2589]\n", - " [ 19301 30289 40134]]\n", - "\n", - "Classification Report:\n", - " precision recall f1-score support\n", - "\n", - " 1 0.92 0.70 0.80 334216\n", - " 2 0.11 0.70 0.20 11855\n", - " 3 0.37 0.45 0.41 89724\n", - "\n", - " accuracy 0.65 435795\n", - " macro avg 0.47 0.62 0.47 435795\n", - "weighted avg 0.79 0.65 0.70 435795\n", - "\n", - "\n", - "Accuracy Score:\n", - "0.6486536100689544\n" - ] - } - ], - "source": [ - "# entrainement d un random forest\n", - "\n", - "model_rf_clf = RandomForestClassifier(random_state=42)\n", - "\n", - "start_time = time.time()\n", - "model_rf_clf.fit(X_train_resampled, y_train_resampled)\n", - "end_time = time.time()\n", - "\n", - "training_time = end_time - start_time\n", - "print(f\"Temps d'entraînement du modèle : {training_time:.2f} secondes\")\n", - "\n", - "y_pred = model_rf_clf.predict(X_test)\n", - "\n", - "print(\"Confusion Matrix:\")\n", - "print(confusion_matrix(y_test, y_pred))\n", - "\n", - "print(\"\\nClassification Report:\")\n", - "print(classification_report(y_test, y_pred))\n", - "\n", - "print(\"\\nAccuracy Score:\")\n", - "print(accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "87015d5b", - "metadata": { - "id": "87015d5b" - }, - "outputs": [], - "source": [ - "# nous souhaitons un modele predisant mieux les gravites eleves,\n", - "# on sauvegarde donc le modele avec la meilleure\n", - "import joblib\n", - "with open('model_rf_clf.pkl', 'wb') as file:\n", - " joblib.dump(model_rf_clf, file)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50efc55d-af21-4676-b371-98c2f02077e0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}