Tutoriel de classification Naive Bayes avec Scikit-learn

Processus de classification

Lorsque vous effectuez une classification, la première étape consiste à comprendre le problème et à identifier les caractéristiques et les étiquettes potentielles. Les caractéristiques sont les caractéristiques ou les attributs qui affectent les résultats de l'étiquette. Par exemple, dans le cas de la distribution d'un prêt, les directeurs de banque identifient la profession du client, ses revenus, son âge, sa localisation, l'historique de ses prêts précédents, l'historique de ses transactions et sa cote de crédit. Ces caractéristiques sont connues sous le nom de caractéristiques qui aident le modèle à classer les clients.

La classification comporte deux phases, une phase d'apprentissage et une phase d'évaluation. Dans la phase d'apprentissage, le classificateur entraîne son modèle sur un ensemble de données donné, et dans la phase d'évaluation, il teste les performances du classificateur. Les performances sont évaluées sur la base de différents paramètres tels que l'exactitude, l'erreur, la précision et le rappel.

Qu'est-ce que le classificateur Naive Bayes ?

Naive Bayes est une technique de classification statistique basée sur le théorème de Bayes. Il s'agit de l'un des algorithmes d'apprentissage supervisé les plus simples. Le classificateur Naive Bayes est un algorithme rapide, précis et fiable. Les classificateurs Naive Bayes ont une précision et une vitesse élevées sur les grands ensembles de données.

Le classificateur Naive Bayes part du principe que l'effet d'une caractéristique particulière dans une classe est indépendant des autres caractéristiques. Par exemple, un demandeur de prêt est désirable ou non en fonction de ses revenus, de son historique de prêts et de transactions, de son âge et de sa situation géographique. Même si ces caractéristiques sont interdépendantes, elles sont toujours considérées comme indépendantes. Cette hypothèse simplifie les calculs, c'est pourquoi elle est considérée comme naïve. Cette hypothèse est appelée indépendance conditionnelle de classe.

• P(h) : la probabilité que l'hypothèse h soit vraie (indépendamment des données). C'est ce qu'on appelle la probabilité préalable de h.
• P(D) : la probabilité des données (indépendamment de l'hypothèse). C'est ce que l'on appelle la probabilité préalable.
• P(h|D) : la probabilité de l'hypothèse h compte tenu des données D. Il s'agit de la probabilité postérieure.
• P(D|h) : la probabilité d'obtenir des données d si l'hypothèse h est vraie. C'est ce que l'on appelle la probabilité postérieure.

Comment fonctionne le classificateur Naive Bayes ?

Comprenons le fonctionnement de Naive Bayes à l'aide d'un exemple. Donnez un exemple des conditions météorologiques et de la pratique du sport. Vous devez calculer la probabilité de pratiquer un sport. Vous devez maintenant déterminer si les joueurs joueront ou non, en fonction des conditions météorologiques.

Première approche (dans le cas d'un seul élément)

Le classificateur Naive Bayes calcule la probabilité d'un événement en suivant les étapes suivantes :

• Étape 1: Calculer la probabilité a priori pour des étiquettes de classe données
• Étape 2: Trouvez la probabilité de vraisemblance avec chaque attribut pour chaque classe.
• Étape 3: Introduisez ces valeurs dans la formule de Bayes et calculez la probabilité postérieure.
• Étape 4: Déterminez la classe dont la probabilité est la plus élevée, étant donné que l'entrée appartient à la classe dont la probabilité est la plus élevée.

Pour simplifier le calcul des probabilités a priori et a posteriori, vous pouvez utiliser les deux tableaux suivants : les tableaux de fréquence et les tableaux de vraisemblance. Ces deux tableaux vous aideront à calculer les probabilités a priori et a posteriori. Le tableau des fréquences contient l'occurrence des étiquettes pour toutes les caractéristiques. Il existe deux tableaux de vraisemblance. Le tableau de vraisemblance 1 indique les probabilités a priori des étiquettes et le tableau de vraisemblance 2 indique la probabilité a posteriori.

Supposons maintenant que vous souhaitiez calculer la probabilité de jouer lorsque le temps est couvert.

Probabilité de jouer :

P(Oui | Couvert) = P(Couvert | Oui) P(Oui) / P (Couvert) .....................(1)

1. Calculer les probabilités préalables :

   P(ciel couvert) = 4/14 = 0,29

   P(Oui)= 9/14 = 0,64

1. Calculez les probabilités postérieures :

   P(ciel couvert |Oui) = 4/9 = 0,44

1. Introduisez les probabilités antérieures et postérieures dans l'équation (1)

   P (Oui | Couvert) = 0,44 * 0,64 / 0,29 = 0,98 (plus élevé)

De même, vous pouvez calculer la probabilité de ne pas jouer :

Probabilité de ne pas jouer :

P(Non | Couvert) = P(Couvert | Non) P(Non) / P (Couvert) .....................(2)

1. Calculer les probabilités préalables :

   P(ciel couvert) = 4/14 = 0,29

   P(Non)= 5/14 = 0,36

1. Calculez les probabilités postérieures :

   P(ciel couvert |non) = 0/9 = 0

1. Introduisez les probabilités antérieures et postérieures dans l'équation (2)

   P (Non | Couvert) = 0 * 0,36 / 0,29 = 0

La probabilité d'une classe "oui" est plus élevée. Vous pouvez donc déterminer ici que si le temps est couvert, les joueurs pratiqueront ce sport.

Deuxième approche (en cas de caractéristiques multiples)

Supposons maintenant que vous souhaitiez calculer la probabilité de jouer lorsque le temps est couvert et que la température est douce.

Probabilité de jouer :

P(Jouer= Oui | Météo=Couvert, Temp=Doux) = P(Météo=Couvert, Temp=Doux | Jouer= Oui)P(Jouer=Oui) ..........(1)

P(Temps=Couvert, Temp=Doux | Jouer= Oui)= P(Couvert |Oui) P(Doux |Oui) ...........(2)

1. Calculer les probabilités préalables : P(Oui)= 9/14 = 0,64

2. Calculez les probabilités postérieures : P(Couvert |Oui) = 4/9 = 0,44 P(Doux |Oui) = 4/9 = 0,44

3. Introduisez les probabilités postérieures dans l'équation (2) P(Météo=Surchauffe, Temp=Doux | Jouer= Oui) = 0,44 * 0,44 = 0,1936(Plus élevé)

4. Mettez les probabilités antérieures et postérieures dans l'équation (1) P(Play= Yes | Weather=Overcast, Temp=Mild) = 0.1936*0.64 = 0.124

De même, vous pouvez calculer la probabilité de ne pas jouer :

Probabilité de ne pas jouer :

P(Jouer=Non | Météo=Couvert, Temp=Doux) = P(Météo=Couvert, Temp=Doux | Jouer=Non)P(Jouer=Non) ..........(3)

P(Météo=Couvert, Temp=Doux | Jeu=Non)= P(Météo=Couvert |Jeu=Non) P(Temp=Doux |Jeu=Non) ...........(4)

1. Calculer les probabilités préalables : P(Non)= 5/14 = 0,36

2. Calculez les probabilités postérieures : P(Météo=Ciel couvert |Jeu=Non) = 0/9 = 0 P(Temp=Doux |Jeu=Non)=2/5=0.4

3. Introduisez les probabilités postérieures dans l'équation (4) P(Weather=Overcast, Temp=Mild | Play= No) = 0 * 0.4= 0

4. Mettez les probabilités a priori et a posteriori dans l'équation (3) P(Play= No | Weather=Overcast, Temp=Mild) = 0*0.36=0

La probabilité d'une classe "oui" est plus élevée. On peut donc dire que si le temps est couvert, les joueurs pratiqueront ce sport.

Construction d'un classificateur dans Scikit-learn

Classificateur Naive Bayes avec un ensemble de données synthétiques

Dans le premier exemple, nous générerons des données synthétiques à l'aide de scikit-learn et nous entraînerons et évaluerons l'algorithme Gaussian Naive Bayes. 

Création de l'ensemble de données

Scikit-learn nous fournit un écosystème d'apprentissage automatique qui vous permet de générer l'ensemble de données et d'évaluer divers algorithmes d'apprentissage automatique. 

Dans notre cas, nous créons un jeu de données avec six caractéristiques, trois classes et 800 échantillons en utilisant la fonction `make_classification`. 

from sklearn.datasets import make_classification

X, y = make_classification(
    n_features=6,
    n_classes=3,
    n_samples=800,
    n_informative=2,
    random_state=1,
    n_clusters_per_class=1,
)

Nous utiliserons la fonction `scatter` de matplotlib.pyplot pour visualiser l'ensemble des données. 

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1], c=y, marker="*");

Comme nous pouvons le constater, il existe trois types d'étiquettes cibles, et nous allons entraîner un modèle de classification multiclasse. 

Train Test Split

Avant de commencer le processus d'apprentissage, nous devons diviser l'ensemble de données en deux parties, l'une pour l'apprentissage et l'autre pour le test, afin d'évaluer le modèle. 

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Construction de modèles et formation 

Construisez un Naive Bayes gaussien générique et entraînez-le sur un ensemble de données d'entraînement. Ensuite, introduisez un échantillon de test aléatoire dans le modèle pour obtenir une valeur prédite.

from sklearn.naive_bayes import GaussianNB

# Build a Gaussian Classifier
model = GaussianNB()

# Model training
model.fit(X_train, y_train)

# Predict Output
predicted = model.predict([X_test[6]])

print("Actual Value:", y_test[6])
print("Predicted Value:", predicted[0])

Les valeurs réelles et prédites sont identiques. 

Actual Value: 0
Predicted Value: 0

Évaluation du modèle

Nous ne ferons pas évoluer le modèle sur un ensemble de données de test inédit. Tout d'abord, nous allons prédire les valeurs de l'ensemble de données de test et les utiliser pour calculer la précision et le score F1. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
)

y_pred = model.predict(X_test)
accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Notre modèle a donné d'assez bons résultats avec les hyperparamètres par défaut. 

Accuracy: 0.8484848484848485
F1 Score: 0.8491119695890328

Pour visualiser la matrice de confusion, nous utiliserons `confusion_matrix` pour calculer les vrais positifs et les vrais négatifs et `ConfusionMatrixDisplay` pour afficher la matrice de confusion avec les étiquettes.

labels = [0,1,2]
cm = confusion_matrix(y_test, y_pred, labels=labels)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Notre modèle a donné d'assez bons résultats, et nous pouvons l'améliorer par la mise à l'échelle, le prétraitement des validations croisées et l'optimisation des hyperparamètres. 

Classificateur Naive Bayes avec l'ensemble de données de prêt

Entraînons le classificateur Naive Bayes sur le jeu de données réel. Nous répéterons la plupart des tâches, à l'exception du prétraitement et de l'exploration des données. 

Chargement des données

Dans cet exemple, nous allons charger des données de prêt depuis DataLab en utilisant la fonction pandas "read_csv`". 

import pandas as pd


df = pd.read_csv('loan_data.csv')
df.head()

Data Exploration

Pour en savoir plus sur l'ensemble des données, nous utiliserons `.info()`.

• L'ensemble de données comprend 14 colonnes et 9578 lignes.
• Hormis le "but", les colonnes sont soit des flottants, soit des entiers. 
• Notre colonne cible est "non.entièrement.payé". 

df.info()

RangeIndex: 9578 entries, 0 to 9577
Data columns (total 14 columns):
#   Column             Non-Null Count  Dtype 
---  ------             --------------  ----- 
0   credit.policy      9578 non-null   int64 
1   purpose            9578 non-null   object
2   int.rate           9578 non-null   float64
3   installment        9578 non-null   float64
4   log.annual.inc     9578 non-null   float64
5   dti                9578 non-null   float64
6   fico               9578 non-null   int64 
7   days.with.cr.line  9578 non-null   float64
8   revol.bal          9578 non-null   int64 
9   revol.util         9578 non-null   float64
10  inq.last.6mths     9578 non-null   int64 
11  delinq.2yrs        9578 non-null   int64 
12  pub.rec            9578 non-null   int64 
13  not.fully.paid     9578 non-null   int64 
dtypes: float64(6), int64(7), object(1)
memory usage: 1.0+ MB

Dans cet exemple, nous allons développer un modèle pour prédire les clients qui n'ont pas entièrement remboursé leur prêt. Explorons la colonne des objectifs et des cibles en utilisant le graphique de comptage de seaborn. 

import seaborn as sns
import matplotlib.pyplot as plt

sns.countplot(data=df,x='purpose',hue='not.fully.paid')
plt.xticks(rotation=45, ha='right');

Notre ensemble de données présente un déséquilibre qui affectera les performances du modèle. Vous pouvez consulter le tutoriel Rééchantillonner un ensemble de données dés équilibré pour acquérir une expérience pratique de la gestion des ensembles de données déséquilibrés.

Traitement des données 

Nous allons maintenant convertir la colonne "purpose" de catégorique à entier en utilisant la fonction pandas `get_dummies`.

pre_df = pd.get_dummies(df,columns=['purpose'],drop_first=True)
pre_df.head()

Ensuite, nous définirons les variables caractéristiques (X) et cibles (y), et nous diviserons l'ensemble de données en ensembles de formation et de test. 

from sklearn.model_selection import train_test_split

X = pre_df.drop('not.fully.paid', axis=1)
y = pre_df['not.fully.paid']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=125
)

Construction de modèles et formation

La construction du modèle et la formation sont très simples. Nous allons entraîner un modèle sur un ensemble de données d'entraînement en utilisant des hyperparamètres par défaut. 

from sklearn.naive_bayes import GaussianNB

model = GaussianNB()

model.fit(X_train, y_train);

Évaluation du modèle

Nous utiliserons la précision et le score f1 pour déterminer la performance du modèle, et il semble que l'algorithme Gaussian Naive Bayes ait donné d'assez bons résultats. 

from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    ConfusionMatrixDisplay,
    f1_score,
    classification_report,
)

y_pred = model.predict(X_test)

accuray = accuracy_score(y_pred, y_test)
f1 = f1_score(y_pred, y_test, average="weighted")

print("Accuracy:", accuray)
print("F1 Score:", f1)

Accuracy: 0.8206263840556786
F1 Score: 0.8686606980013266

En raison de la nature déséquilibrée des données, nous pouvons constater que la matrice de confusion raconte une histoire différente. Sur un objectif minoritaire : "pas entièrement payé", nous avons plus d'erreurs d'étiquetage. 

labels = ["Fully Paid", "Not fully Paid"]
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
disp.plot();

Si vous rencontrez des problèmes lors de l'entraînement ou de l'évaluation du modèle, vous pouvez consulter le tutoriel de classification Naive Bayes utilisant le manuel Scikit-learn DataLab. Il est accompagné d'un ensemble de données, du code source et des résultats. 

Problème de probabilité zéro

Supposons qu'il n'y ait pas de tuple pour un prêt à risque dans l'ensemble de données ; dans ce cas, la probabilité a posteriori sera nulle et le modèle ne pourra pas faire de prédiction. Ce problème est connu sous le nom de probabilité zéro, car l'occurrence d'une classe particulière est nulle.

La solution à ce problème est la correction du Laplacien ou la transformation de Laplace. La correction du laplacien est l'une des techniques de lissage. Ici, vous pouvez supposer que l'ensemble de données est suffisamment grand pour que l'ajout d'une ligne de chaque classe ne fasse pas de différence dans la probabilité estimée. Cela permettra de résoudre le problème des valeurs de probabilité à zéro.

Par exemple : Supposons que la base de données contienne 1 000 tuples de formation pour la classe "prêt risqué". Dans cette base de données, la colonne des revenus comporte 0 tuples pour les faibles revenus, 990 tuples pour les revenus moyens et 10 tuples pour les revenus élevés. Les probabilités de ces événements, sans la correction du Laplacien, sont 0, 0,990 (à partir de 990/1000) et 0,010 (à partir de 10/1000).

Appliquez maintenant la correction laplacienne à l'ensemble de données donné. Ajoutons 1 tuple supplémentaire pour chaque paire revenu-valeur. Les probabilités de ces événements :

Avantages

• Il s'agit non seulement d'une approche simple, mais aussi d'une méthode de prédiction rapide et précise.
• Le coût de calcul de Naive Bayes est très faible.
• Il peut travailler efficacement sur un grand ensemble de données.
• Il donne de bons résultats dans le cas d'une variable de réponse discrète par rapport à une variable continue.
• Il peut être utilisé pour des problèmes de prédiction de classes multiples.
• Il donne également de bons résultats dans le cas des problèmes d'analyse de texte.
• Lorsque l'hypothèse d'indépendance est respectée, un classificateur Naive Bayes est plus performant que d'autres modèles tels que la régression logistique.

Inconvénients

• L'hypothèse de caractéristiques indépendantes. Dans la pratique, il est pratiquement impossible d'obtenir un ensemble de prédicteurs entièrement indépendants.
• S'il n'y a pas de tuple d'apprentissage d'une classe particulière, la probabilité postérieure est nulle. Dans ce cas, le modèle n'est pas en mesure de faire des prédictions. Ce problème est connu sous le nom de problème de probabilité zéro/fréquence.

Conclusion

Félicitations, vous avez atteint la fin de ce tutoriel !

Dans ce tutoriel, vous avez appris à connaître l'algorithme de Naïve Bayes, son fonctionnement, l'hypothèse de Naïve Bayes, les problèmes, la mise en œuvre, les avantages et les inconvénients. En cours de route, vous avez également appris la construction et l'évaluation de modèles dans scikit-learn pour les classes binaires et multinomiales.

Naive Bayes est l'algorithme le plus simple et le plus puissant. Malgré les avancées significatives de l'apprentissage automatique au cours des deux dernières années, il a fait ses preuves. Il a été déployé avec succès dans de nombreuses applications, de l'analyse de texte aux moteurs de recommandation.

Si vous souhaitez en savoir plus sur scikit-learn en Python, suivez notre cours Apprentissage supervisé avec scikit-learn et consultez notre tutoriel Scikit-Learn : Baseball Analytics Pt 1.