Régression logistique

La régression logistique est une méthode statistique utilisée pour modéliser la relation entre une variable dépendante binaire (ou catégorielle) et une ou plusieurs variables indépendantes. L’objectif principal est d’estimer la probabilité qu’un événement se produise en fonction des variables explicatives.

Contrairement à la régression linéaire, la régression logistique ne prédit pas directement une valeur numérique, mais une probabilité comprise entre 0 et 1. Pour ce faire, elle utilise la fonction logistique (ou sigmoïde) qui transforme une combinaison linéaire des variables indépendantes en une probabilité.

Les coefficients du modèle sont estimés en maximisant la vraisemblance des observations, ce qui permet de trouver les paramètres qui rendent les résultats observés les plus probables. La régression logistique permet également d’évaluer l’influence de chaque variable explicative sur la probabilité de l’événement étudié.

Cette méthode est utilisée en science des données, médecine, marketing, finance, et dans de nombreux autres domaines pour prédire des événements binaires, classifier des observations, et identifier les facteurs qui influencent un résultat.

La qualité du modèle peut être évaluée à l’aide de métriques telles que l’exactitude, l’aire sous la courbe ROC (AUC), la matrice de confusion, et les tests de significativité des coefficients.

En résumé, la régression logistique est un outil interprétable pour modéliser des relations entre variables et prédire des probabilités d’événements binaires.

Fonctions :

LogisticRegression()

La fonction LogisticRegression() permet d'implémenter un modèle de régression logistique pour des tâches de classification binaire ou multiclasse. C’est un modèle très populaire pour prédire des classes en fonction des caractéristiques d’entrée. Ce modèle utilise la méthode de maximum de vraisemblance pour estimer les paramètres.

Importation :

from sklearn.linear_model import LogisticRegression

Attributs :

Paramètre	Description
`penalty`	Type de régularisation à utiliser. Les options sont `'l1'`, `'l2'`, `'elasticnet'` et `'none'`. Par défaut, il est égal à `'l2'`.
`dual`	Si `True`, le problème de la régularisation est formulé de manière duale. À utiliser uniquement avec `solver='liblinear'`. Par défaut, `False`.
`tol`	Critère de tolérance pour l'optimisation. Plus ce nombre est faible, plus l'optimisation doit être précise. Par défaut, il est égal à `1e-4`.
`C`	Paramètre de régularisation. Plus la valeur est faible, plus la régularisation est forte. Par défaut, il est égal à `1.0`.
`fit_intercept`	Booléen. Si `True`, le modèle inclura un terme d'interception (biais). Par défaut, il est égal à `True`.
`intercept_scaling`	Un facteur de mise à l'échelle de l'interception. Utilisé uniquement lorsque `solver='liblinear'` et `fit_intercept=True`. Par défaut, il est égal à `1`.
`class_weight`	Poids des classes. Peut être `None` (pas de poids spécifiques) ou un dictionnaire où les clés sont les classes et les valeurs les poids. Par défaut, `None`.
`solver`	Algorithme d'optimisation à utiliser. Les options sont `'newton-cg'`, `'lbfgs'`, `'liblinear'`, `'sag'`, et `'saga'`. Par défaut, il est égal à `'lbfgs'`.
`max_iter`	Le nombre maximal d'itérations pour l'optimiseur. Par défaut, il est égal à `100`.
`multi_class`	Stratégie utilisée pour la classification multiclasse. Les options sont `'ovr'` (un contre tous) et `'multinomial'`. Par défaut, il est égal à `'ovr'`.
`warm_start`	Booléen. Si `True`, les solutions précédentes sont utilisées pour initialiser les paramètres au lieu de recommencer l'optimisation de zéro. Par défaut, il est égal à `False`.
`n_jobs`	Le nombre de jobs parallèles à utiliser. Par défaut, il est égal à `None` (aucun parallélisme).
`l1_ratio`	Le ratio de l'ElasticNet (utilisé uniquement lorsque `penalty='elasticnet'`). Par défaut, il est égal à `None`.
`verbose`	Si `True`, affiche des informations détaillées pendant l'ajustement du modèle. Par défaut, il est égal à `0` (aucune information).
`random_state`	Contrôle la randomisation du modèle. Peut être un entier, une instance de générateur de nombres aléatoires ou `None`. Par défaut, il est égal à `None`.

Exemple de code :

# Importation de la classe LogisticRegression
from sklearn.linear_model import LogisticRegression

# Création d'un modèle de régression logistique
model = LogisticRegression(C=1.0, penalty='l2', solver='lbfgs')

# Entraînement du modèle sur des données d'exemple
X_train = [[1, 2], [2, 3], [3, 4]]
y_train = [0, 1, 0]
model.fit(X_train, y_train)

# Prédiction sur de nouvelles données
X_test = [[2, 3], [3, 4]]
predictions = model.predict(X_test)

# Affichage des prédictions
print(predictions)

Explication du code :

Création d’un modèle de régression logistique

model = LogisticRegression(C=1.0, penalty='l2', solver='lbfgs') crée un modèle de régression logistique avec les paramètres suivants :

C=1.0 : paramètre d'inverse de la régularisation. Une valeur plus faible de C applique une régularisation plus forte (plus de pénalité sur les grands coefficients).

penalty='l2' : indique que la régularisation utilisée est de type L2 (norme quadratique), qui tend à éviter les coefficients extrêmes.

solver='lbfgs' : algorithme d’optimisation utilisé pour entraîner le modèle. Ici, lbfgs est un solveur efficace pour les petits jeux de données.

Entraînement du modèle

X_train = [[1, 2], [2, 3], [3, 4]] définit les données d’entraînement sous forme de liste de listes (3 échantillons avec 2 caractéristiques chacun).

y_train = [0, 1, 0] contient les étiquettes cibles associées à chaque échantillon d’entraînement. Ce sont ici des classes binaires (0 ou 1).

model.fit(X_train, y_train) entraîne le modèle de régression logistique sur les données d’entrée X_train et les étiquettes y_train. Le modèle apprend à distinguer les classes 0 et 1.

Prédiction sur de nouvelles données

X_test = [[2, 3], [3, 4]] définit de nouvelles données pour lesquelles on souhaite prédire la classe.

predictions = model.predict(X_test) utilise le modèle entraîné pour prédire les classes associées aux échantillons de X_test.
Le résultat est stocké dans la variable predictions.

Affichage des prédictions

print(predictions) affiche les classes prédites (0 ou 1) pour les données de test fournies.
Cela donne un aperçu de la capacité du modèle à classer correctement de nouvelles entrées.