keyboard_arrow_down 🧭 Guide complet pour créer un modèle ML

Comprendre le problème

Objectif : Prédire si une personne est atteinte d’une maladie cardiaque (target = 1) ou non (target = 0).

Dataset fourni :

Contient des informations médicales (âge, sexe, tension, cholestérol, etc.)

13 colonnes explicatives + 1 colonne cible (target)

Remarque pour participants :

Vous pouvez supprimer certaines colonnes si elles ne sont pas utiles.

Vous pouvez ajouter des colonnes/features dérivées.
Le nettoyage des données dépend du dataset que vous utilisez.

Téléchargement du DataSet

!gdown 1ey475h0Bino79TfDBrdbq0aqG7mfv_1Q -O [Link]

Downloading...
From: [Link]
To: /content/[Link]
100% 38.1k/38.1k [00:00<00:00, 70.9MB/s]

Explication
1️⃣ !gdown
Dans Google Colab, le point d’exclamation ! indique que tu exécutes une commande shell (comme dans un terminal
Linux).

gdown est un outil Python qui permet de télécharger des fichiers directement depuis Google Drive via leur ID.

Il est pratique pour automatiser le téléchargement dans Colab ou sur un serveur, sans avoir à ouvrir Google Drive dans
un navigateur. 2️⃣ 1ey475h0Bino79TfDBrdbq0aqG7mfv_1Q

C’est l’ID du fichier Google Drive.

Sur Google Drive, un fichier partageable a une URL comme :

[Link]

La partie entre /d/ et /view est l’ID.

gdown utilise cet ID pour retrouver le fichier exact à télécharger.

3️⃣ -O [Link]
-O signifie Output, c’est-à-dire le nom que tu veux donner au fichier une fois téléchargé.
 Ici, le fichier téléchargé sera enregistré localement dans ton environnement Colab sous le nom [Link].

Si tu ne mets pas -O, gdown gardera le nom original du fichier sur Drive.

keyboard_arrow_down Importation des packages

# 📦 Packages pour manipulation et visualisation

import pandas as pd
import numpy as np
import [Link] as plt
import seaborn as sns

# ⚙️ Prétraitement
from [Link] import StandardScaler
from sklearn.model_selection import train_test_split

# 🧠 Modèles de ML
from xgboost import XGBClassifier
from [Link] import DecisionTreeClassifier
from [Link] import KNeighborsClassifier

# 📊 Évaluation
from [Link] import confusion_matrix, accuracy_score, classification_report, roc_curve

# 🔗 Ensembling
from [Link] import StackingCVClassifier

keyboard_arrow_down Chargement du dataset

# 📂 Chargement du dataset
data = pd.read_csv('[Link]') # Remplacer par le chemin réel
[Link]() # Affiche les premières lignes

age sex cp trestbps chol fbs restecg thalach exang oldpeak slope ca thal target

0 52 1 0 125 212 0 1 168 0 1.0 2 2 3 0

1 53 1 0 140 203 1 0 155 1 3.1 0 0 3 0

2 70 1 0 145 174 0 1 125 1 2.6 0 0 3 0

3 61 1 0 148 203 0 1 161 0 0.0 2 1 3 0

4 62 0 0 138 294 1 1 106 0 1.9 1 3 2 0

Étapes suivantes : Générer du code avec data New interactive sheet

keyboard_arrow_down Exploration des données (EDA)

# Vérifier les informations générales

[Link]()

# Vérifier les valeurs manquantes

print([Link]().sum())

# Statistiques descriptives
[Link]()
 <class '[Link]'>
RangeIndex: 1025 entries, 0 to 1024
Data columns (total 14 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 age 1025 non-null int64
1 sex 1025 non-null int64
2 cp 1025 non-null int64
3 trestbps 1025 non-null int64
4 chol 1025 non-null int64
5 fbs 1025 non-null int64
6 restecg 1025 non-null int64
7 thalach 1025 non-null int64
8 exang 1025 non-null int64
9 oldpeak 1025 non-null float64
10 slope 1025 non-null int64
11 ca 1025 non-null int64
12 thal 1025 non-null int64
13 target 1025 non-null int64
dtypes: float64(1), int64(13)
memory usage: 112.2 KB
age 0
sex 0
cp 0
trestbps 0
chol 0
fbs 0
restecg 0
thalach 0
exang 0
oldpeak 0
slope 0
ca 0
thal 0
target 0
dtype: int64
age sex cp trestbps chol fbs restecg thalach e

count 1025.000000 1025.000000 1025.000000 1025.000000 1025.00000 1025.000000 1025.000000 1025.000000 1025.00

mean 54.434146 0.695610 0.942439 131.611707 246.00000 0.149268 0.529756 149.114146 0.33

std 9.072290 0.460373 1.029641 17.516718 51.59251 0.356527 0.527878 23.005724 0.47

min 29.000000 0.000000 0.000000 94.000000 126.00000 0.000000 0.000000 71.000000 0.00

25% 48.000000 0.000000 0.000000 120.000000 211.00000 0.000000 0.000000 132.000000 0.00

50% 56.000000 1.000000 1.000000 130.000000 240.00000 0.000000 1.000000 152.000000 0.00

75% 61.000000 1.000000 2.000000 140.000000 275.00000 0.000000 1.000000 166.000000 1.00

max 77.000000 1.000000 3.000000 200.000000 564.00000 1.000000 2.000000 202.000000 1.00

Commentaire :

info() : type et taille des colonnes.

isnull() : valeurs manquantes.

describe() : moyenne, min, max, etc.

keyboard_arrow_down Préparation des données

# Séparer les features et la target

y = data["target"] # Variable à prédire (maladie ou non)
X = [Link]('target', axis=1)

# Diviser en train et test

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

# Normalisation
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = [Link](X_test)
 # Vérification de l'équilibre des classes
from collections import Counter
print(Counter(y_train))

Counter({1: 423, 0: 397})

💡 Commentaire sur la gestion des données

Remarque importante : La préparation des données dépend fortement du dataset utilisé. Dans cet exemple (Heart
Disease), nous n’avions pas de valeurs manquantes ni de nettoyage complexe à faire, mais dans d’autres datasets :

Vous pouvez supprimer des données si certaines lignes ou colonnes sont inutiles ou contiennent trop de valeurs
manquantes.

Vous pouvez ajouter des données (features) si cela peut améliorer la prédiction, par exemple en combinant des colonnes
ou en créant des variables dérivées.

Data cleaning (nettoyage des données) est une étape cruciale : traitement des valeurs manquantes, conversion des
catégories, détection des valeurs aberrantes, etc. Chaque dataset peut nécessiter des méthodes différentes.

Conseil pour les participants : Toujours analyser vos données (.info(), .describe(), .isnull()) avant d’entraîner le modèle. Cela
vous aidera à décider quelles colonnes nettoyer, supprimer ou créer.

keyboard_arrow_down Modélisation

Decision Tree

dt = DecisionTreeClassifier(criterion='entropy', max_depth=6, random_state=42)

[Link](X_train, y_train)
dt_pred = [Link](X_test)

print("Decision Tree Accuracy:", accuracy_score(y_test, dt_pred))

print(classification_report(y_test, dt_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, dt_pred))

Decision Tree Accuracy: 0.8731707317073171

precision recall f1-score support

0 0.94 0.79 0.86 102

1 0.82 0.95 0.88 103

accuracy 0.87 205

macro avg 0.88 0.87 0.87 205
weighted avg 0.88 0.87 0.87 205

Confusion Matrix:
[[81 21]
[ 5 98]]

K-Nearest Neighbors

knn = KNeighborsClassifier(n_neighbors=10)
[Link](X_train, y_train)
knn_pred = [Link](X_test)

print("KNN Accuracy:", accuracy_score(y_test, knn_pred))

print(classification_report(y_test, knn_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, knn_pred))

KNN Accuracy: 0.8390243902439024

precision recall f1-score support

0 0.83 0.84 0.84 102

1 0.84 0.83 0.84 103

accuracy 0.84 205

macro avg 0.84 0.84 0.84 205
weighted avg 0.84 0.84 0.84 205
 Confusion Matrix:
[[86 16]
[17 86]]

XGBoost

xgb = XGBClassifier(learning_rate=0.01, n_estimators=25, max_depth=15, random_state=42)

[Link](X_train, y_train)
xgb_pred = [Link](X_test)

print("XGBoost Accuracy:", accuracy_score(y_test, xgb_pred))

print(classification_report(y_test, xgb_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, xgb_pred))

XGBoost Accuracy: 0.8780487804878049

precision recall f1-score support

0 0.91 0.83 0.87 102

1 0.85 0.92 0.88 103

accuracy 0.88 205

macro avg 0.88 0.88 0.88 205
weighted avg 0.88 0.88 0.88 205

Confusion Matrix:
[[85 17]
[ 8 95]]

Visualisation de l’importance des features (XGBoost)

imp_feature = [Link]({'Feature': [Link], 'Importance': xgb.feature_importances_})

[Link](figsize=(10,5))
[Link](imp_feature['Feature'], imp_feature['Importance'], color='skyblue')
[Link]("Importance")
[Link]("Feature")
[Link]("Feature Importance - XGBoost")
[Link]()

Courbes ROC (comparaison des modèles)

dt_fpr, dt_tpr, _ = roc_curve(y_test, dt_pred)

knn_fpr, knn_tpr, _ = roc_curve(y_test, knn_pred)
xgb_fpr, xgb_tpr, _ = roc_curve(y_test, xgb_pred)

[Link](figsize=(10,5))
 [Link](dt_fpr, dt_tpr, label='Decision Tree')
[Link](knn_fpr, knn_tpr, label='KNN')
[Link](xgb_fpr, xgb_tpr, label='XGBoost')
[Link]([0,1],[0,1], ls='--') # ligne diagonale
[Link]("False Positive Rate")
[Link]("True Positive Rate")
[Link]("ROC Curve")
[Link]()
[Link]()

keyboard_arrow_down Enregistrer les modeles

from joblib import dump, load

# 1️⃣ Enregistrer les modèles

# Decision Tree
dump(dt, 'decision_tree_model.joblib')

# K-Nearest Neighbors
dump(knn, 'knn_model.joblib')

# XGBoost
dump(xgb, 'xgboost_model.joblib')

print("Modèles enregistrés avec succès !")

Modèles enregistrés avec succès !

 Remarque pickle est une autre bibliothèque Python pour sérialiser (enregistrer) des objets, y compris des modèles de
machine learning. Voici un aperçu concret avec tes modèles

Enregistrer un modèle avec pickle

import pickle

# Decision Tree
with open('decision_tree_model.pkl', 'wb') as f:
[Link](dt, f)

# K-Nearest Neighbors
with open('knn_model.pkl', 'wb') as f:
[Link](knn, f)

# XGBoost
with open('xgboost_model.pkl', 'wb') as f:
[Link](xgb, f)

print("Modèles enregistrés avec pickle !")

keyboard_arrow_down charger un modèle

# Charger Decision Tree

loaded_dt = load('decision_tree_model.joblib')
y_pred_dt_loaded = loaded_dt.predict(X_test)

# Charger KNN
loaded_knn = load('knn_model.joblib')
y_pred_knn_loaded = loaded_knn.predict(X_test)

# Charger XGBoost
loaded_xgb = load('xgboost_model.joblib')
y_pred_xgb_loaded = loaded_xgb.predict(X_test)

Remarque: pickle est une autre bibliothèque Python pour sérialiser (enregistrer) et désérialiser (charger) des objets, y
compris des modèles de machine learning. Voici un aperçu concret avec tes modèles

Charger un modèle avec pickle

# Decision Tree
with open('decision_tree_model.pkl', 'rb') as f:
loaded_dt = [Link](f)
y_pred_dt_loaded = loaded_dt.predict(X_test)

# KNN
with open('knn_model.pkl', 'rb') as f:
loaded_knn = [Link](f)
y_pred_knn_loaded = loaded_knn.predict(X_test)

# XGBoost
with open('xgboost_model.pkl', 'rb') as f:
loaded_xgb = [Link](f)
y_pred_xgb_loaded = loaded_xgb.predict(X_test)

Comparaison pickle vs joblib

Critère pickle joblib

Usage Sérialisation générale Optimisé pour numpy et modèles ML volumineux

Vitesse Moins rapide Plus rapide pour gros tableaux numpy

 Critère pickle joblib

Taille du fichier Plus grande Plus compacte pour modèles ML

Compatibilité Python uniquement Python uniquement

💡 Conseil : Pour des modèles ML avec beaucoup de données (ex. XGBoost), joblib est souvent plus
performant. Mais pickle fonctionne aussi très bien pour des modèles plus petits comme Decision Tree ou
KNN.

🔹 Conclusion
1. Préparation des données : La qualité du modèle dépend fortement de la préparation et du nettoyage des données.
Vérifiez toujours les valeurs manquantes, les types de colonnes et normalisez si nécessaire.

2. Choix du modèle : Différents modèles ont des forces différentes :

Decision Tree : facile à interpréter et rapide à entraîner.

K-Nearest Neighbors : performant pour des petites datasets et sensible à la normalisation.
XGBoost : souvent le plus précis grâce à l’optimisation et l’ensembling interne.

3. Évaluation et comparaison : Toujours comparer plusieurs modèles sur des métriques adaptées (accuracy, F1-score,
confusion matrix) avant de choisir le meilleur modèle.

4. Amélioration du modèle : Vous pouvez améliorer les résultats en ajoutant ou supprimant des features, en ajustant les
hyperparamètres ou en utilisant des techniques d’ensembling.

5. Documentation et reproductibilité : Pour un projet de compétition, documenter chaque étape du pipeline (pré-
traitement, modélisation, évaluation) permet aux autres de comprendre votre approche et de reproduire vos résultats.

En résumé :
Ce guide montre comment construire un modèle ML étape par étape, depuis l’analyse du dataset jusqu’à l’évaluation finale,
en utilisant Decision Tree, KNN et XGBoost. Il sert de base solide pour les participants afin de développer leur propre
solution et expérimenter différentes approches