Régression logistique

La régression logistique est un modèle statistique utilisé pour prédire une variable dépendante binaire (ou catégorique) en fonction de variables indépendantes. Contrairement à la régression linéaire qui prédit une valeur continue, la régression logistique est utilisée lorsque la variable cible

$y$

$y$ prend deux valeurs possibles (par exemple, 0 ou 1, vrai ou faux, oui ou non).

Le modèle de régression logistique calcule la probabilité qu’un événement se produise, basée sur les valeurs des variables indépendantes.

Formule de la Régression Logistique

Le modèle de régression logistique utilise la fonction sigmoïde (ou fonction logistique) pour transformer la sortie de la régression linéaire en une probabilité, dont les valeurs sont comprises entre 0 et 1. L’équation de la régression logistique est :

$p(y=1|x) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 x_1 + \beta_2 x_2 + \dots + \beta_n x_n)}}$

$p (y = 1∣ x) = 1 + e ^{- (β 0 + β 1 x 1 + β 2 x 2 + \dots + β n x n)} 1$

où :

$p(y=1|x)$ $p (y = 1∣ x)$ : probabilité que la variable cible

$y$ $y$ soit égale à 1 (par exemple, un événement positif),
$\beta_0$ $β_{0}$ : intercept,
$\beta_1, \dots, \beta_n$ $β_{1}, \dots, β_{n}$ : coefficients des variables indépendantes

$x_1, x_2, \dots, x_n$ $x_{1}, x_{2}, \dots, x_{n}$ ,
$e$ $e$ : base du logarithme naturel.

L’argument de la fonction sigmoïde est la somme pondérée des variables indépendantes, qui est ensuite transformée pour être entre 0 et 1.

Interprétation des Paramètres

$\beta_0$ $β_{0}$ (intercept) : L’intercept de l’équation est l’odds log lorsque toutes les variables indépendantes sont égales à zéro.
$\beta_1, \dots, \beta_n$ $β_{1}, \dots, β_{n}$ : Ce sont les log-odds des changements dans la probabilité de l’événement pour chaque unité de changement dans les variables

$x_1, x_2, \dots, x_n$ $x_{1}, x_{2}, \dots, x_{n}$ .

Odds et Odds Ratio

La régression logistique repose sur les odds (cotes), qui sont le rapport des probabilités de succès sur les probabilités d’échec. L’odds ratio mesure l’effet d’une unité de changement dans la variable indépendante sur l’odds (ou cotes).

$\beta_1 = 0.5$

$β_{1} = 0.5$ , cela signifie qu’une unité d’augmentation dans

$x_1$

$x_{1}$ multiplie l’odds par

$e^{0.5}$

$e^{0.5}$ , c’est-à-dire environ 1.65.

Équation des Odds

Les odds sont donnés par la relation :

$\text{odds}(y=1|x) = \frac{p(y=1|x)}{1 – p(y=1|x)}$

$odds (y = 1∣ x) = 1 - p ( y = 1∣ x ) p ( y = 1∣ x )$

Cela transforme la probabilité en un rapport de chances.

Fonction Sigmoïde

La fonction sigmoïde

$\sigma(z)$

$σ (z)$ est définie par :

$\sigma(z) = \frac{1}{1 + e^{-z}}$

$σ (z) = 1 + e ^{- z} 1$

où

$z$

$z$ est la somme pondérée des variables indépendantes (i.e.,

$z = \beta_0 + \beta_1 x_1 + \dots + \beta_n x_n$

$z = β_{0} + β_{1} x_{1} + \dots + β_{n} x_{n}$ ).

Hypothèses de la Régression Logistique

Les hypothèses sous-jacentes à la régression logistique sont :

Relation linéaire entre les prédicteurs et les log-odds : La relation entre les variables indépendantes et le logarithme des cotes (log-odds) est linéaire.
Indépendance des erreurs : Les erreurs doivent être indépendantes.
Absence de multicolinéarité : Les variables indépendantes ne doivent pas être trop corrélées entre elles.

Fonctions :

LogisticRegression()

La fonction LogisticRegression() de scikit-learn est utilisée pour effectuer une régression logistique, qui est une méthode statistique de classification pour prédire des résultats binaires (par exemple, "oui" ou "non", 0 ou 1). La régression logistique modélise la probabilité qu'une donnée appartienne à une classe spécifique à l'aide d'une fonction logistique (sigmoïde). Elle est largement utilisée pour des problèmes où l'objectif est de prédire une probabilité, telle que la détection de fraude ou la classification de maladies.

Importation :

from sklearn.linear_model import LogisticRegression

Attributs :

Nom	Type	Description
penalty	str, optionnel	La pénalité à appliquer pour régulariser le modèle. Les valeurs possibles sont "l1", "l2", ou "none". (par défaut, "l2")
C	float, optionnel	Le paramètre de régularisation inverse. Un C plus petit implique une régularisation plus forte. (par défaut, 1.0)
solver	str, optionnel	Le solver à utiliser pour l'optimisation. Les valeurs possibles sont "lbfgs", "liblinear", "newton-cg", "saga", et "saga". (par défaut, "lbfgs")
max_iter	int, optionnel	Le nombre maximal d'itérations à utiliser pour l'optimisation. (par défaut, 100)
random_state	int, optionnel	Le générateur de nombres aléatoires pour contrôler la reproductibilité des résultats.

Exemple de code :

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
import numpy as np
import matplotlib.pyplot as plt

# Chargement d'un jeu de données d'exemple (iris dataset)
data = load_iris()
X = data.data
y = (data.target == 0).astype(int)  # 1 si l'espèce est setosa, 0 sinon

# Séparation des données en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Initialisation du modèle de régression logistique
model = LogisticRegression()

# Entraînement du modèle
model.fit(X_train, y_train)

# Prédictions
y_pred = model.predict(X_test)

# Affichage des résultats
accuracy = np.mean(y_pred == y_test)
print(f'Précision du modèle: {accuracy:.2f}')

# Affichage des coefficients
print(f'Coefficients du modèle: {model.coef_}')

Explication du code :

from sklearn.linear_model import LogisticRegression importe la classe LogisticRegression de la bibliothèque scikit-learn, qui est utilisée pour effectuer une régression logistique.

from sklearn.model_selection import train_test_split importe la fonction train_test_split, qui permet de diviser un jeu de données en ensembles d'entraînement et de test.

from sklearn.datasets import load_iris importe la fonction load_iris, qui charge le célèbre jeu de données Iris, utilisé pour des tâches de classification.

import numpy as np importe la bibliothèque numpy, renommée ici en np, qui est utilisée pour effectuer des opérations numériques, comme la gestion des tableaux.

import matplotlib.pyplot as plt importe la bibliothèque matplotlib, renommée ici en plt, utilisée pour créer des graphiques et des visualisations.

Chargement d'un jeu de données d'exemple (iris dataset)

data = load_iris() charge le jeu de données Iris et l'assigne à la variable data. Ce jeu contient des informations sur 150 fleurs d'iris, réparties en trois classes d'espèces.

X = data.data récupère les caractéristiques (features) des fleurs (longueur et largeur des sépales et des pétales) sous forme de tableau NumPy et les assigne à X.

y = (data.target == 0).astype(int) crée un vecteur binaire y, où la valeur est 1 si l'espèce de l'iris est "setosa" (espèce 0), et 0 sinon. Cela permet de transformer la tâche en une classification binaire.

Séparation des données en ensemble d'entraînement et de test

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) divise le jeu de données en deux ensembles : 70% des données sont utilisées pour l'entraînement (X_train, y_train) et 30% pour le test (X_test, y_test). Le paramètre random_state=42 permet de garantir la reproductibilité de la séparation des données.

Initialisation du modèle de régression logistique

model = LogisticRegression() initialise un objet de la classe LogisticRegression, représentant le modèle de régression logistique qui sera utilisé pour prédire la classe de l'espèce d'iris.

Entraînement du modèle

model.fit(X_train, y_train) entraîne le modèle de régression logistique sur les données d'entraînement X_train et les étiquettes y_train. Le modèle apprend à prédire l'espèce d'iris en fonction des caractéristiques des fleurs.

Prédictions

y_pred = model.predict(X_test) effectue des prédictions sur l'ensemble de test X_test en utilisant le modèle entraîné. Les prédictions sont stockées dans y_pred.

Affichage des résultats

accuracy = np.mean(y_pred == y_test) calcule la précision du modèle, c'est-à-dire la proportion de prédictions correctes, en comparant les prédictions y_pred avec les valeurs réelles y_test.

print(f'Précision du modèle: {accuracy:.2f}') affiche la précision du modèle avec deux décimales.

Affichage des coefficients

print(f'Coefficients du modèle: {model.coef_}') affiche les coefficients appris par le modèle de régression logistique. Ces coefficients représentent l'importance de chaque caractéristique dans la prédiction de la classe de l'iris. Plus la valeur d'un coefficient est élevée, plus la caractéristique correspondante influence la prédiction.