Implémentation de la régression logistique

Dans cette leçon, nous allons mettre en œuvre une régression logistique à l’aide de la bibliothèque scikit-learn. Nous travaillerons avec un jeu de données de classification binaire.

Étape 1 : importer les bibliothèques et le jeu de données

Nous commencerons par importer les bibliothèques nécessaires et charger un jeu de données. Pour simplifier, nous utiliserons la fonction make_classification de scikit-learn afin de générer un jeu de données de classification binaire.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Generate dataset
X, y = make_classification(n_samples=100, n_features=2, n_classes=2, random_state=42)

# Split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Étape 2 : créer le modèle de régression logistique

Nous utilisons la classe LogisticRegression de scikit-learn pour créer et entraîner le modèle.

model = LogisticRegression()
model.fit(X_train, y_train)

Étape 3 : effectuer des prédictions

Une fois le modèle entraîné, nous l’utilisons pour effectuer des prédictions sur les données de test.

y_pred = model.predict(X_test)

Étape 4 : évaluer le modèle

Nous évaluons les performances du modèle en utilisant l’exactitude comme métrique.

accuracy = accuracy_score(y_test, y_pred)
print(f"Model Accuracy: {accuracy:.2f}")

Étape 5 : visualiser les frontières de décision

Pour mieux comprendre les performances du modèle, nous visualisons les frontières de décision.

import matplotlib.pyplot as plt
import numpy as np

# Define grid for plotting
def plot_decision_boundary(X, y, model):
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))

    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    plt.contourf(xx, yy, Z, alpha=0.8)
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k')
    plt.title('Decision Boundary')
    plt.show()

plot_decision_boundary(X, y, model)

Étape 6 : régler le modèle

Nous pouvons améliorer les performances du modèle en ajustant des hyperparamètres comme C, qui contrôle la force de la régularisation.

model = LogisticRegression(C=0.5)
model.fit(X_train, y_train)

Ces difficultés comprennent :

• La gestion des jeux de données déséquilibrés.
• La prise en compte de caractéristiques fortement corrélées.
• La garantie d’un volume suffisant de données d’entraînement pour effectuer des prédictions efficaces.

Dans cette leçon, nous avons :

• Mis en œuvre une régression logistique à l’aide de scikit-learn.
• Effectué des prédictions et évalué le modèle.
• Visualisé les frontières de décision.

Nous allons maintenant découvrir comment évaluer les performances d’un modèle à l’aide de métriques comme le score F1, la précision et le rappel.