Comparaison de Modèles de Classification

Ce projet compare plusieurs algorithmes de machine learning supervisé sur un jeu de données simulé. Les étapes clés sont illustrées, du prétraitement à la visualisation des performances.

1. Génération et Prétraitement des Données

Génération d'un jeu de données synthétique avec 5 variables et 2 classes.
Séparation en 80% pour l'entraînement et 20% pour le test.
Standardisation des features pour améliorer la performance des modèles.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Génération du jeu de données
X, y = make_classification(n_samples=100, n_features=5, n_classes=2, random_state=42)
# Découpage 80/20
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Standardisation : transformation des données pour avoir une moyenne de 0 et écart-type de 1.
scaler = StandardScaler() #échelle comparable
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

2. Construction et Entraînement des Modèles

Test de 6 modèles classiques : KNN, Random Forest, SVM, Régression Logistique, Arbre de Décision, Naive Bayes.
Stockage des scores d'accuracy et de précision pour chaque modèle.


models = {
    #classe un point selon la majorité de ses 5 voisins les plus proches.
    "KNN": KNeighborsClassifier(n_neighbors=5),

    #crée 100 arbres de décision différents et vote parmi leurs prédictions pour choisir la classe finale.
    "RF": RandomForestClassifier(n_estimators=100, random_state=42),

    #cherche la "meilleure ligne" (ou plan) qui sépare les classes.
    "SVM": SVC(kernel='linear', random_state=42),

    #calcule une probabilité que chaque point appartienne à une classe à l’aide d’une fonction sigmoïde.
    "LR": LogisticRegression(random_state=42),

    #divise l’espace de décision en posant des questions (noeuds) pour trier les données.
    "DT": DecisionTreeClassifier(random_state=42),

    #utilise les probabilités (et la loi normale) pour estimer la classe la plus probable.
    "NB": GaussianNB()
}

accuracies, precisions, model_names = [], [], []

for name, clf in models.items():
    clf.fit(X_train_scaled, y_train)
    y_pred = clf.predict(X_test_scaled)

    #mesure la proportion de bonnes prédictions parmi toutes les prédictions faites.
    acc = accuracy_score(y_test, y_pred)

    #mesure la proportion de vraies prédictions positives parmi toutes les prédictions positives effectuées.
    precision = precision_score(y_test, y_pred)
    accuracies.append(acc)
    precisions.append(precision)
    model_names.append(name)

3. Évaluation et Visualisation

Comparaison des scores d'accuracy et de précision pour chaque modèle.
Visualisation sous forme de graphique en barres.

Modèle	Accuracy
KNN	1
RF	0.90
SVM	1
LR	1
DT	0.85
NB	1

import matplotlib.pyplot as plt

x = range(len(model_names))
fig, ax = plt.subplots(figsize=(10, 6))
bar_width = 0.35
ax.bar(x, accuracies, bar_width, label='Accuracy', color='b')
ax.set_xlabel('Models')
ax.set_ylabel('Scores')
ax.set_title('Model Performance Comparison')
ax.set_xticks([p + bar_width/2 for p in x])
ax.set_xticklabels(model_names)
ax.legend()
plt.show()

On peut voir que pour notre jeux de donnèes, les modèles random forest et decision tree sont précis que le reste des modèle.