Tuto Python & Scikit-learn : la régression logistique

Table des matières

Introduction

Dans le présent tutoriel, nous allons voir le deuxième type de régression, qui est la régression logistique, en utilisant la bibliothèque d’apprentissage automatique Scikit-learn.

L’algorithme de régression logistique est un algorithme de classification plutôt que de régression, il se base sur un ensemble de données indépendantes et il est ainsi utilisé pour estimer une valeur discrète.

1. Définition

L’algorithme de régression logistique mesure la relation entre la variable dépendante catégorielle et une ou plusieurs variables indépendantes en donnant une estimation à la probabilité d’occurrence d’un événement à travers l’usage de sa fonction logistique.

Il existe plusieurs types de régression logistique, à savoir :

Régression logistique binaire : la variable cible n’a que deux résultats possibles, comme par exemple « cancer » ou « pas de cancer ».
Régression logistique multinomiale : la variable cible a trois catégories nominales ou plus, comme par exemple la prédiction du type d’un iris.
Régression logistique ordinale : la variable cible a trois catégories ordinales ou plus, comme la notation des produits de 1 à 5.

2. Régression linéaire Vs. Régression Logistique

Comme nous l’avons vu dans le tutoriel précédent, la régression linéaire donne un résultat continu. La régression logistique quant à elle, donne un résultat constant.

Prenons l’exemple des prix des maisons et des actions dans la bourse, ce sont alors des exemples de production continue. Par contre, la prédiction qu’un patient qui souffre d’un cancer ou non est un exemple de sortie discrète. Nous identifions également l’exemple de la prédiction du taux de désabonnement de client.

Cependant, la régression linéaire est estimée en utilisant la méthode des moindres carrés ordinaire (MOC), tandis que la régression logistique est estimée en utilisant l’approche de l’estimateur au maximum de vraisemblance (EMV).

3. Module Scikit-learn

La bibliothèque d’apprentissage automatique Scikit-learn fournit pour la régression logistique le module sklearn.linear_model.LogisticRegression.

LogisticRegression peut prendre plusieurs paramètres dont :

- random_state : représente la graine du nombre pseudo-aléatoire généré. Ce dernier est utilisé lors de la réorganisation de données. Il peut prendre trois options, notamment :

int : random_state dans ce cas est la graine utilisée par le générateur de nombres aléatoires.
RandomState instance : random_state dans ce cas est le générateur de nombres aléatoires.
None : le générateur de nombres aléatoires est l’instance RandomState qui est utilisée par np.random.

Par défaut ce paramètre prend None.

- solver : ce paramètre représente l’algorithme à utiliser pour le problème d’optimisation. Il peut prendre l’une des options suivantes :

linlinear : le meilleur choix pour les petits ensembles de données. Il gère la pénalité L1.
newton-cg : gère que la pénalité L2.
lbfgs : gère la perte multinomiale pour les problèmes multi classes. Il ne gère également que la pénalité L2.
saga : représente un bon choix pour les grands ensembles de données. Pour les problèmes multi classes, il gère les pertes multinomiales. Il prend en charge la pénalité L1 et la pénalité « elasticnet».
sag : cette option est aussi idéale pour les grands ensembles de données et gère la perte multinomiale pour les problèmes multi classes.

Par défaut ce paramètre prend linlinear.

- multi_class : ce paramètre présente les options suivantes :

ovr : si cette option est choisie, donc un problème binaire est adapté à chaque étiquette.
multin : si cette option est choisie, alors la perte minimisée est l’ajustement de la perte multinomiale sur l’ensemble de la distribution de probabilité. Cette option ne marche pas avec le solveur « lbfgs».

Par défaut ce paramètre prend ovr.

4. Attributs de la régression logistique

Les attributs du LogisticRegression sont les suivants :

- coef_ : renvoi le coefficient des caractéristiques de la fonction de décision.

- intercept_ : représente la constante ajoutée à la fonction de décision.

- n_iter_ : renvoi le nombre réel d’itérations pour chaque classe.

Afin de bien assimiler le fonctionnement du modèle de régression logistique, nous allons exploiter le data-set suivant qui concerne les fruits. Où le but est de prédire l’étiquette d’un fruit.

Tout d’abord, nous allons importer les modules numpy, pandas et sklearn (uniquement les éléments dont on a besoin), ensuite on charge le fichier Excel comprenant les données. Puis, on affiche les cinq premiers enregistrements de l’ensemble des données à l’aide de la fonction head() afin d’avoir une idée sur la dataset.

Code :

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_spli
from sklearn import linear_model
df = pd.read_excel('C:/Users/LENOVO/Desktop/coursGratuit/fruitDataset.xlsx')
df.head()

Résultat de l’exécution :

On crée ci-contre une correspondance entre la valeur de l’étiquette du fruit et son nom dans le but de faciliter l’interprétation des résultats. Puis, on définit deux variables x et y représentant respectivement des valeurs caractéristiques et la valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble de données en données d’entrainement et de test suivant le pourcentage par défaut 75/25%.

On crée par la suite une instance de l’objet LogisticRegression, qu’on lui passe en paramètres random_state, solver et multi_class.

Finalement, on entraine cette instance en utilisant la méthode fit() qu’on lui passe en paramètre x_train et y_train. Puis, en faisant appel à la méthode score() on calcule la précision du modèle.

Code :

nom_fruit_cible = dict( zip (df.etiquette_fruit.unique(), df.nom_fruit.unique()))
print( nom_fruit_cible )
#valeurs caractéristiques et valeur cible
x = df [['poids', 'largeur', 'hauteur']]
y = df['etiquette_fruit']
#fractionner dataset
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)
#instanciation du modèle
modele_regLog = linear_model.LogisticRegression(random_state = 0,
solver = 'liblinear', multi_class = 'auto')
#training
modele_regLog.fit(x_train,y_train)
#précision du modèle
precision = modele_regLog.score(x_test,y_test)
print(precision*100)

Résultat de l’exécution :

On donne au modèle de régression logistique le poids, la largeur et la hauteur d’un fruit et on lui demande de classifier ce fruit en utilisant la méthode de prédiction predict().

Code :

#prédiction
prediction_fruit = modele_regLog.predict([[180,8.0,6.8]])
nom_fruit_cible[prediction_fruit[0]]
#prédiction
prediction_fruit = modele_regLog.predict([[20,4.3,5.5]])
nom_fruit_cible[prediction_fruit[0]]

Résultat de l’exécution :

5. Cas d’utilisation

La régression logistique peut être mise en œuvre pour des compagnes de ciblage marketing. Le but ainsi est d’attirer de nouveaux clients. Alors, la construction d’un modèle de régression logistique permettra d’expliquer et de prédire les clients susceptibles d’acheter le produit ou le service offert par l'entreprise.

À titre d’exemple, Booking.com utilise plusieurs algorithmes d’apprentissage automatique sur tout son site. Ces algorithmes essayent de prédire les intentions des utilisateurs. Et vu que dans la plupart des cas les données sont plutôt catégoriques que numériques tel que la distinction sur la base du lieu d’origine de l’utilisateur et l’endroit où il veut se rendre. La régression logistique est alors idéale pour prévoir un événement sans avoir des données spécifiques concernant l’utilisateur.

En plus de ces deux exemples, le modèle de régression logistique est utilisé dans le domaine médical, dans le text editing et dans le gaming.

6. Avantages et limites

6.1. Avantages

La régression logistique est un algorithme de classification simple et efficace, alors il ne nécessite pas une grande puissance de calcul et il est facile à mettre en œuvre. Ce modèle d’apprentissage est largement utilisé par les analystes de données et les scientifiques et il ne nécessite pas de mise à l’échelle des fonctionnalités.

Enfin, la régression logistique fournit un score de probabilité pour les observations.

6.2. Limites

La régression logistique n’est pas adaptée à un grand nombre de caractéristiques. Cet algorithme ne peut pas résoudre le problème de non-linéarité ce qui nécessite la transformation des caractéristiques non linéaires.

Ainsi, la régression logistique ne fonctionne pas bien avec des variables indépendantes qui ne sont pas corrélées à la variable cible et qui sont très similaires entre elles.

7. Exercices

7.1. Exercice 1

Appliquez le modèle de régression logistique sur la dataset “iris“.

7.2. Exercice 2

Appliquez le modèle de régression logistique sur la dataset “pima“ qui a pour objectif de prévoir si un patient est diabétique ou non. Vous pouvez télécharger cette dataset depuis Kaggle :https://www.kaggle.com/uciml/pima-indians-diabetes-database

8. Solution des exercices

8.1. Exercice 1

Tout d’abord, nous allons importer les modules numpy, pandas et sklearn (uniquement les éléments dont on a besoin), ensuite on charge le fichier Excel comprenant les données. Puis on affiche les cinq premiers enregistrements de l’ensemble des données à l’aide de la fonction head() afin d’avoir une idée sur la dataset.

Puis on définit deux variables x et y représentant respectivement des valeurs caractéristiques et la valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble de données en données d’entrainement et de test suivant le pourcentage 80/20%.

On crée par la suite une instance de l’objet LogisticRegression, qu’on lui passe en paramètres random_state, solver et multi_class.

On entraine cette instance en utilisant la méthode fit() qu’on lui passe en paramètre x_train et y_train. Puis, en faisant appel à la méthode score() on calcule la précision du modèle.

Finalement, pour prédire le type d’un iris, on donne au modèle la longueur et la largeur de celui-ci et on lui applique la méthode predict().

Code :

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import linear_model
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/iris.csv')
df.head()
a = df.loc[:,"petal_length"]
b = df.loc[:,"petal_width"]
x = list(zip(a, b))
y = df.loc[:,"species"]
#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.20)
#instanciation du modèle
modele_regLog = linear_model.LogisticRegression(random_state = 0,
solver = 'liblinear', multi_class = 'auto')
#training
modele_regLog.fit(x_train, y_train)
#calcule de précision
precision = modele_regLog.score(x_test, y_test)
print(precision * 100)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = modele_regLog.predict([[longueur, largeur]])
#affichage des résultats
resultat = "Résultat : "
if prediction[0] == 0:
resultat = resultat + "setosa"
if prediction[0] == 1:
resultat = resultat + "versicolor"
if prediction[0] == 2:
resultat = resultat + "virginica"
print(resultat)

Résultat de l’exécution :

8.2. Exercice 2

Dans cet exercice, nous avons tout d’abord importé les modules numpy, pandas et sklearn (uniquement les éléments dont on a besoin). Ensuite, on charge le fichier CSV comprenant les données. Puis on affiche les cinq premiers enregistrements de l’ensemble des données à l’aide de la fonction head() afin d’avoir une idée sur la dataset. On a aussi donné de nouveaux noms aux colonnes du fichier en ajoutant aux paramètres deread_csv, names. Finalement, on a supprimé la première ligne qui contenait les anciens noms à l’aide de drop().

Code :

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import linear_model
nom_colonne = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi',
'pedigree', 'age', 'label']
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/diabetes.csv',
header = None, names = nom_colonne)
df = df.drop([0])
df.head()

Résultat de l’exécution :

On définit deux variables x et y représentant respectivement des valeurs caractéristiques et la valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble de données en données d’entrainement et de test suivant le pourcentage par défaut 75/25%.

On crée par la suite une instance de l’objet LogisticRegression. On entraine cette instance en utilisant la méthode fit() qu’on lui passe en paramètre x_train et y_train. Pour prédire si une personne est diabétique ou non on donne au modèle les valeurs de test et on lui applique la méthode predict().

Puis, en faisant appel à la méthode score() on calcule la précision du modèle.

Code :

caracteristique = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp', 'pedigree']
x = df[caracteristique]
y = df.label
#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y,
test_size = 0.25, random_state = 0)
#instanciation du modèle
modele_regLog = linear_model.LogisticRegression()
#training
modele_regLog.fit(x_train, y_train)
#prediction
prediction = modele_regLog.predict(x_test)
print('prédiction du modèle:', prediction)
#calcule de précision
precision = modele_regLog.score(x_test, prediction)
print('la précision du modèle', precision * 100)

Résultat de l’exécution :

Conclusion

La régression logistique est l’un des modèles classiques d’apprentissage automatique. Elle est considérée des bases de la machine learning. La simplicité de ce modèle lui a permis cette réputation auprès des scientifiques ainsi que les personnes souhaitant s’initier au monde de l’apprentissage automatique.

Pour conclure, lors de ce tutoriel nous avons défini le modèle de régression logistique et sa différence de la régression linéaire. Ensuite, on a vu la classe fournie par scikit-learn pour ce type de régression et qu’on a appliquée sur un exemple de dataset. Finalement, nous avons vu différents cas d’utilisations réelles de cet algorithme, ses avantages, ainsi que ses limites.

Article publié le 25 Novembre 2020par Imane BENHMIDOU