Tuto Python & Scikit-learn: la classification Naïve Bayésienne

Table des matières

Introduction

1. Definition
2. Module Scikit-learn

2.1. Gaussian Naîve Bayes

2.2. Bernoulli Naîve Bayes

3. Cas d’utilisation
4. Avantages et limites de l’algorithme

4.1. Avantages

4.2. Limites

5. Exercices

5.1. Exercice 1

5.2. Exercice 2

6. Solution des exercices

6.1. Solution de l’exercice 1

6.2. Solution de l’exercice 2

Conclusion

Introduction

Le Naîve Bayes Classifier (classifieur bayésien naïf ou classifieur naïf de Bayes) est un modèle d’apprentissage automatique de type supervisé permettant la classification en se basant sur le théorème de Bayes avec une forte indépendance des hypothèses (c’est-à-dire pas de corrélation entre les caractéristiques d’un ensemble de données). Cette classification appartient à la catégorie des classifieurs linéaires.

1. Definition

Nous définirons dans ce qui suit des notions nécessaires à l’apprentissage et la maîtrise du classifieur Naîf Bayesien.

Tout d’abord, le théorème de Bayes décrit la probabilité d’une caractéristique en se basant au préalable sur des situations liées à celle-ci. Par exemple, si la probabilité qu’une personne soit diabétique est liée à son âge, alors en utilisant ce théorème, on peut utiliser l’âge pour prédire avec plus de précision la probabilité de souffrir de cette maladie chronique.

Le mot naïf dans l’intitulé de l’algorithme implique que chaque paire de caractéristiques dans l’ensemble des données en question est indépendante de l’autre. C’est-à-dire que la valeur d’une caractéristique particulière est indépendante de la valeur de toute autre caractéristique pour une classe donnée. Par exemple, un fruit est classé comme une pomme s’il est rond, s’il a un diamètre d’environ 13 cm et s’il est de couleur rouge. Avec le Naîve Bayes Classifier, chacune des trois caractéristiques : forme, taille, et couleur contribuent indépendamment à la probabilité que ce fruit soit une pomme. On suppose, en plus, qu’il n’y a pas de corrélation entre la forme, la taille et la couleur.

Dans la majorité des cas, vous allez faire face à des caractéristiques continues. Dans ce cas, l’algorithme en question suppose que les valeurs continues associées à chaque classe sont distribuées selon une distribution normale.

2. Module Scikit-learn

La bibliothèque Scikit-learn de Python destinée à l’apprentissage automatique fourni le module sklearn.naîve_bayes qui contient plusieurs classificateurs Bayes Naïfs, dont chacun performe mieux sur un certain type de donnée.

Les types de classificateurs que la bibliothèque contient sont les suivants :

• Gaussian Naîve Bayes ;
• Multinomial Naîve Bayes ;
• Complement Naîve Bayes ;
• Bernoulli Naîve Bayes ;
• Categorical Naîve Bayes.

Nous nous intéresserons lors de ce tutoriel au classificateur Gaussien et Bernoulli.

2.1. Gaussian Naîve Bayes

Afin de découvrir concrètement le fonctionnement de l’algorithme Gaussian Naîve Bayes,  nous l’appliquerons sur un ensemble de données contenant trois caractéristiques : Glucose, pression artérielle et diabète afin de classifier si une personne est atteinte de diabète ou non (1 pour oui 0 sinon).

Alors, nous importons dans un premier temps les éléments nécessaires, à savoir : pandas, train_test_split, GaussianNB et accuracy_score. Ensuite, nous chargeons le fichier csv contenant les données et nous affichons les résultats à l’aide de la fonction head(). Ainsi, nous afficherons uniquement les cinq premiers enregistrements pour avoir une idée sur l’ensemble de données.

• Code :

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naîve_bayes import GaussianNB
from sklearn.metrics import accuracy_score
df = pd.read_csv( 'C:/Users/LENOVO/Desktop/coursGratuit/diabete.csv')
df.head()

• Résultat de l’exécution :

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

Ensuite, on crée une instance de l’objet GaussianNB et on l’entraine à l’aide de la méthode fit() qu’on lui passe en paramètre x_train et y_train.

On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ensuite le résultat avec les valeurs y_test afin de calculer la précision du modèle.

• Code :

a = df['glucose']
b = df['pressionArterielle']
x = list(zip(a, b))
y = df['diabete']
#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.20)
#instanciation
model_Gaussian = GaussianNB()
#training
model_Gaussian.fit(x_train, y_train)
#prédiction
prediction = model_Gaussian.predict(x_test)
print(prediction)
#evaluation du modèle
precision = accuracy_score(y_test, prediction)*100
print(precision)

• Résultat de l’exécution :

2.2. Bernoulli Naîve Bayes

En guise de découverte de l’algorithme Bernoulli Naîve Bayes, nous l’appliquerons sur un ensemble de données contenant quatre caractéristiques principales : Sexe, taille, poids et pointure. Dans le but de classifier si une personne est de sexe féminin ou masculin.

Alors, on importe dans un premier temps les éléments nécessaires à savoir pandas, train_test_split, BernoulliNB et accuracy_score. Ensuite, on charge le fichier Excel contenant les données et on affiche tous les enregistrements pour avoir une idée sur l’ensemble de données.

• Code :

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naîve_bayes import BernoulliNB
from sklearn.metrics import accuracy_score
df = pd.read_excel('C:/Users/LENOVO/Desktop/coursGratuit/personne.xlsx')
print(df)

• Résultat de l’exécution :

On définit ensuite deux variables x et y représentant respectivement les valeurs de caractéristiques et la valeur cible. Puis, on utilise la fonction train_test_split pour fractionner l’ensemble des données en données de train et de test avec un pourcentage de 80% pour les données d’entraînement et 20 % pour les données de test.

Ensuite, on crée une instance de l’objet BernoulliNB, on l’entraine à l’aide de la méthode fit() qu’on lui passe en paramètres x_train et y_train.

On fait une prédiction des valeurs de test à l’aide de la méthode predict() et on compare par la suite ses valeurs avec les valeurs y_test pour calculer la précision du modèle.

• Code :

#Encodage
sexe = dict( zip (df.etiquette.unique(), df.Sexe.unique()))
print( sexe )
x = df[['Taille', 'Poids', 'Pointure']]
y = df['Sexe']

• Résultat de l’exécution :

• Code :

#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.20)
#instanciation
model_Bernoulli = BernoulliNB()
#training
model_Bernoulli.fit(x_train, y_train)
#prédiction
prediction = model_Bernoulli.predict(x_test)
print(prediction)
#evaluation du modèle
precision = accuracy_score(y_test, prediction)*100
print(precision)

• Résultat de l’exécution :

3. Cas d’utilisation

Le Naîve Bayes Classifier peut être appliqué dans différents scénarios, un des cas d’utilisation classiques pour ce modèle d’apprentissage est la classification des documents. Il s’agit de déterminer si un document correspond à certaines catégories ou pas.

Il est aussi utilisé pour :

• Le filtrage de spam ;
• L’analyse des sentiments ;
• Les systèmes de recommandation.

4. Avantages et limites de l’algorithme

4.1. Avantages

Le Naîve Bayes Classifier est l’algorithme de classification le plus simple et le plus rapide. Les calculs de probabilités ne sont pas couteux d’où sa rapidité.

Ce modèle d’apprentissage ne nécessite qu’un nombre faible d’échantillons d’entraînement par rapport à d’autres modèles, comme la régression logistique et les arbres de décision, pour effectuer une classification efficace. Il convient aussi aux larges ensembles de données. 

4.2. Limites

Le Naîve Bayes Classifier suppose que les variables sont indépendantes, ce qui n’est toujours pas vrai dans les cas réels.

En effet, si la corrélation entre les caractéristiques est grande, ce modèle d’apprentissage va donner une mauvaise performance.

5. Exercices

5.1. Exercice 1 

Appliquez le modèle Gaussian Naîve Bayes sur l’ensemble de données suivant :

5.2. Exercice 2 

Appliquez le Gaussian Naîve Bayes sur l’ensemble des données load_breast_cancer de sklearn.

6. Solution des exercices

6.1. Solution de l’exercice 1 

Dans cet exercice, on importe dans un premier temps les éléments nécessaires, à savoir : pandas, train_test_split, GaussianNB et accuracy_score. Ensuite, on charge le fichier Excel contenant les données et on affiche tous les enregistrements pour avoir une idée sur l’ensemble de données.

• Code :

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naîve_bayes import GaussianNB
from sklearn.metrics import accuracy_score
df = pd.read_excel ('C:/Users/LENOVO/Desktop/coursGratuit/personne.xlsx')
print(df)

• Résultat de l’exécution :

On définit ensuite deux variables x et y représentant respectivement les valeurs de caractéristiques et la valeur cible. Puis, on utilise la fonction train_test_split pour fractionner l’ensemble des données en données de train et de test avec un pourcentage de 80% pour les données d’entraînement et 20 % pour les données de test.

Ensuite, on crée une instance de l’objet GaussianNB et on l’entraine à l’aide de la méthode fit() qu’on lui passe en paramètre x_train et y_train.

On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ses valeurs résultantes avec les valeurs y_test et calculer ensuite la précision du modèle.

• Code :

#Encodage
sexe = dict( zip (df.etiquette.unique(), df.Sexe.unique()))
print( sexe )
x = df[['Taille', 'Poids', 'Pointure']]
y = df['Sexe']
#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.20)
#instanciation
model_Gaussian = GaussianNB()
#training
model_Gaussian.fit(x_train, y_train)
#prédiction
prediction = model_Gaussian.predict(x_test)
print(prediction)
#evaluation du modèle
precision = accuracy_score(y_test, prediction)*100
print(precision)

• Résultat de l’exécution :

6.2. Solution de l’exercice 2 

Dans cet exercice, on importe tout d’abord les éléments load_breast_cancer, train_test_split et train_test_split. Puis, on définit deux variables x et y représentant respectivement les valeurs de caractéristiques et la valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble des données en données de train et de test avec un pourcentage de 80% pour les données d’entraînement et 20 % pour les données de test.

On crée par la suite une instance de l’objet GaussianNB, on l’entraine à l’aide de la méthode fit() qu’on lui passe en paramètre x_train et y_train.

On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ses valeurs résultantes avec les valeur y_test et calculer la précision du modèle.

• Code :

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.naîve_bayes import train_test_split
df = load_breast_cancer()
x = df['data']
y = df['target']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.40, random_state = 42)
#instanciation
model_Gaussian = GaussianNB()
#training
model_Gaussian.fit(x_train, y_train)
#prédiction
prediction = model_Gaussian.predict(x_test)
print(prediction)
#evaluation du modèle
precision = accuracy_score(y_test, prediction)*100
print(precision)

• Résultat de l’exécution :

Conclusion

Lors de ce tutoriel nous avons découvert les étapes d’implémentation pour l’algorithme Naîve Bayes Classifier destiné à la classification. Ainsi, nous avons entrainé deux types de cet algorithme, à savoir le Gaussian Naîve Bayes et le Bernoulli Naîve Bayes, sur différents ensembles de données pour réaliser une prédiction par la suite.