Introduction à l'algorithme naïf de Bayes

Tableau:

Introduction

Naive Bayes est un algorithme d'apprentissage automatique de classification basé sur le théorème de Bayes. Il est très efficace, notamment lorsqu'il s'agit de données textuelles telles que : l'analyse des sentiments, la détection du spam et la classification des textes.

Cet algorithme est appelé « Naïf » en raison de l’hypothèse selon laquelle toutes les variables de l’ensemble de données sont indépendantes, ce qui n’est pas toujours le cas.

Avant d’aller plus loin dans l’explication du fonctionnement de Naive Bayes, assurons-nous de bien comprendre les points suivants :

Probabilité conditionnelle

L’algorithme Naive Bayes est basé sur le théorème de Bayes qui repose sur la probabilité conditionnelle : c’est la probabilité d’occurrence d’un événement A étant donné qu’un événement B s’est déjà produit.

Exemple:

Prenons deux pots contenant des boules colorées :

Le pot 1 contient 3 boules bleues, 2 boules rouges et 4 boules vertes.
Le pot 2 contient 1 boule bleue, 4 boules rouges et 3 boules vertes.

Nous voulons calculer la probabilité de sélectionner au hasard une boule bleue dans l'un des pots.

Ce n’est autre que la somme des probabilités de sélectionner une boule bleue parmi Jar1 ou Jar2.

Maintenant, nous voulons calculer la probabilité de sélectionner une boule bleue étant donné que nous avons sélectionné Jar1 :

Enfin, nous voulons calculer la probabilité de sélectionner Jar1 étant donné que nous avons tiré une boule bleue. Nous utilisons ici le théorème de Bayes qui s'énonce comme suit :

Classification naïve de Bayes

Dans le classificateur Naive Bayes, nous voulons trouver la classe qui maximise la probabilité conditionnelle étant donné le vecteur d'entrée X ; ainsi, Naive Bayes peut être formulé comme suit :

En utilisant le théorème de Bayes, la fonction devient :

Dans cette formulation, il est facile de calculer P(Ci) qui n’est autre que la probabilité de la classe Ci, et il est facile de calculer P(x) qui est la probabilité que l’événement x se produise.

Ce qui est difficile à calculer, c'est P(x|Ci) ; la probabilité de l'événement x étant donné la classe Ci. Pour simplifier davantage cela, nous devons supposer que toutes les variables d’entrée sont indépendantes ; ainsi, on peut écrire :

Et c’est d’ailleurs à cause de cette hypothèse que l’on appelle ce classificateur « Naïf », car on ne peut pas toujours garantir l’indépendance des variables d’entrée. Le classificateur Naive Bayes devient :

En fait, nous pouvons encore simplifier cette formulation en éliminant P(x), car c’est la même pour toutes les classes :

Maintenant, regardons un exemple :

| ------- | -------- | --------------- | ------ |

Ici, nous avons un petit ensemble de données qui contient 3 variables d'entrée : Météo, Heure et Jour de la semaine, et une variable cible : « Dîner » qui indique si une personne prépare ou commande son dîner. Nous aimerions trouver la classe de l'entrée x={Clear, Evening, Weekend} :

Nous devons calculer la probabilité conditionnelle pour la classe « Cuisins » et la classe « Commandes » étant donné l'entrée x={Clear, Evening, Weekend}. La classe prédite est celle ayant la probabilité conditionnelle la plus élevée.

On commence par calculer la probabilité conditionnelle de la classe « Cuisiniers » :

Calculons maintenant chaque probabilité conditionnelle individuellement :

La probabilité que le temps soit "Clair" étant donné que la classe est "Cuisins" est le nombre de lignes avec le temps "Clair" et la classe "Cuisins" sur le nombre total de lignes avec la classe "Cuisins".

Il en va de même pour les autres probabilités conditionnelles :

Maintenant pour la probabilité P(Cooks) c'est le nombre de lignes de classe « Cooks » sur le nombre total de lignes :

Calculons maintenant le produit de ces probabilités :

C'était pour la classe « Cuisiniers », maintenant nous devons faire de même pour la classe « Commandes » :

On calcule les probabilités individuelles :

Et on calcule enfin le produit des probabilités :

Finalement, on prend la classe avec la plus forte probabilité qui est la classe « Cuisiniers » :

Avantages et limites de cet algorithme

Avantages :

C'est un classificateur très rapide.
C'est facile à mettre en œuvre.
Il n’y a pas de phase de formation, mais c’est seulement une inférence.
Il ne faut pas beaucoup de données pour faire des inférences.

Limites:

Naive Bayes suppose que les variables d'entrée sont indépendantes, ce qui n'est pas toujours vrai.

Naive Bayes souffre du problème de fréquence nulle : c'est lorsqu'il attribue une probabilité nulle à une variable d'entrée. Cela mettra à zéro toute la probabilité conditionnelle P(C|x). Une astuce pour éviter cela consiste à utiliser une fréquence minimale de 1 (au lieu de 0) pour toutes les variables.

Exercices

Voici le dataframe du même ensemble de données que nous avons vu dans l’exemple.

Votre tâche consiste à implémenter vous-même Naive Bayes en utilisant Python :

import pandas as pd
dataset = pd.DataFrame()
dataset['Weather'] = ['Clear', 'Cloudy', 'Rainy', 'Rainy', 'Cloudy', 'Clear', 'Snowy', 'Clear', 'Clear']
dataset['Time'] = ['Evening', 'Night', 'Night', 'Midday', 'Midday', 'Night', 'Evening', 'Night', 'Midnight']
dataset['Day'] = ['Weekend', 'Weekday', 'Weekday', 'Weekday', 'Weekend', 'Weekend', 'Weekend', 'Weekday', 'Weekend']
dataset['Class'] = ['Cooks', 'Orders', 'Orders', 'Orders', 'Cooks', 'Cooks', 'Orders', 'Cooks', 'Orders']

def naive_bayes(weather, time, day):

# res_dict = {class1: probability of class 1, class1: probability of class 1
return res_dict

Solution


def naive_bayes(x_weather, x_time, x_day):
  TARGET = 'Dinner' # The name of the target variable
  CLASSES = list(dataset['Dinner'].unique()) # The classes of the target variable
len_dataset = len(dataset) # The length of the dataset
res_dict = {} # res_dict = {class1:probability1, ..., class_n:probability_n}

# for each class of the target classes, we calculate the it's conditional probability
for class_name in CLASSES:
# the number of lines that belong to the class "class_name"
len_c  = len(dataset[ (dataset[TARGET] == class_name) ])

# the number of lines that belong to the class "class_name" and have weather="x_weather"
n_weather = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Weather'] == x_weather) ])
# the number of lines that belong to the class "class_name" and have time="x_time"
n_time = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Time'] == x_time) ])

# the number of lines that belong to the class "class_name" and have day="x_day"
n_day  = len(dataset[ (dataset[TARGET] == class_name) & (dataset['Day'] == x_day) ])

# We calculate the conditional probability:
# P(class|x) = P(weather|class) x P(time|class) x P(day|class) x P(class)
p = (n_weather / len_c) * (n_time / len_c) * (n_day / len_c) * (len_c / len_dataset)        res_dict[class_name] = p
return res_dict

Maîtrisez la science des données et l'IA avec Code Labs Academy ! Rejoignez notre bootcamp en ligne – Options flexibles à temps partiel et à temps plein disponibles.