Introduktion till den naiva Bayes-algoritmen

Tabell:

Intro

Naive Bayes är en klassificeringsalgoritm för maskininlärning som är baserad på Bayes sats. Det är mycket effektivt, särskilt när man hanterar textdata som: Sentimentanalys, skräppostavkänning och textklassificering.

Denna algoritm kallas "Naiv" på grund av antagandet att alla datasetvariabler är oberoende, vilket inte alltid är fallet.

Innan vi går vidare in på att förklara hur Naive bayes fungerar, låt oss se till att vi förstår följande:

Villkorlig sannolikhet

Naiv Bayes-algoritm är baserad på Bayes-satsen som bygger på betingad sannolikhet: det är sannolikheten för att en händelse A inträffar givet att en händelse B redan har inträffat.

Exempel:

Låt oss ha två burkar som innehåller färgade bollar:

Burk 1 har 3 blå bollar, 2 röda bollar och 4 gröna bollar.
Burk 2 har 1 blå boll, 4 röda bollar och 3 gröna bollar.

Vi vill beräkna sannolikheten för att slumpmässigt välja en blå boll från en av burkarna

Det är inget annat än summan av sannolikheterna för att välja en blå boll från Jar1 eller Jar2.

Nu vill vi beräkna sannolikheten för att välja en blå boll med tanke på att vi valde Jar1:

Slutligen vill vi beräkna sannolikheten för att välja Jar1 givet att vi ritade en blå boll. Här använder vi Bayes teorem som anges som följande:

Naiv Bayes-klassificering

I Naive Bayes klassificerare vill vi hitta den klass som maximerar den villkorade sannolikheten givet ingångsvektorn X; sålunda kan Naive Bayes formuleras på följande sätt:

Med användning av Bayes teorem blir funktionen:

I den här formuleringen är det lätt att beräkna P(Ci) som inte är något annat än sannolikheten för klassen Ci, och det är lätt att beräkna P(x) som är sannolikheten för att händelsen x inträffar.

Det som är svårt att beräkna är P(x|Ci); sannolikheten för händelsen x givet klassen Ci. För att ytterligare förenkla detta måste vi anta att alla indatavariabler är oberoende; så kan vi skriva:

Och det är faktiskt på grund av detta antagande som vi kallar denna klassificerare "Naiv", eftersom vi inte alltid kan garantera indatavariablernas oberoende. Den naiva Bayes-klassificeraren blir:

Faktum är att vi kan förenkla denna formulering ytterligare genom att eliminera P(x), eftersom det är samma för alla klasser:

Låt oss nu ta en titt på ett exempel:

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

Här har vi en liten datauppsättning som innehåller 3 indatavariabler: väder, tid och veckodag, och en målvariabel: "Middag" som indikerar om en person lagar mat eller beställer sin middag . Vi skulle vilja hitta klassen för ingången x={Clear, Evening, Weekend}:

Vi måste beräkna den villkorade sannolikheten för klassen "Kockar" och klassen "Beställningar" givet ingången x={Clear, Evening, Weekend}. Den förutsagda klassen är den som har den högsta villkorade sannolikheten.

Vi börjar med att beräkna den villkorade sannolikheten för klassen "Kockar":

Nu beräknar vi varje villkorad sannolikhet på egen hand:

Sannolikheten för väder=”Clear” givet att klassen är “Cooks” är antalet rader med väder “Clear” och klass “Cooks” över det totala antalet rader med klassen “Cooks”

Detsamma gäller de andra villkorade sannolikheterna:

Nu för sannolikheten P(Cooks) är det antalet rader med klassen "Cooks" över det totala antalet rader:

Nu beräknar vi produkten av dessa sannolikheter:

Det var för klassen "Kockar", nu måste vi göra samma sak för klassen "Beställningar":

Vi beräknar de individuella sannolikheterna:

Och slutligen beräknar vi produkten av sannolikheterna:

Slutligen tar vi klassen med högst sannolikhet som är klassen "Kockar":

Fördelar och begränsningar med denna algoritm

Fördelar:

– Det är en väldigt snabb klassificerare.

– Det är lätt att genomföra.

– Det finns ingen träningsfas, utan det är bara slutsatser.

– Det krävs inte mycket data för att dra slutsatser.

Begränsningar:

– Naiv Bayes antar att indatavariablerna är oberoende, vilket inte alltid är sant.

Naive Bayes lider av nollfrekvensproblemet: det är när den tilldelar noll sannolikhet till en indatavariabel. Detta kommer att nollställa all villkorlig sannolikhet P(C|x). Ett knep för att undvika detta är att använda en minimal frekvens på 1 ( istället för 0 ) för alla variabler.

Träning

Här är dataramen för samma datauppsättning som vi har sett i exemplet.

Din uppgift är att implementera Naive Bayes själv med 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

Lösning


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