Introduksjon til den naive Bayes-algoritmen

Bord:

Intro

Naive Bayes er en maskinlæringsalgoritme for klassifisering som er basert på Bayes-teoremet. Det er veldig effektivt, spesielt når du arbeider med tekstdata som: Sentimentanalyse, Spam-deteksjon og tekstklassifisering.

Denne algoritmen kalles "naiv" på grunn av antagelsen om at alle datasettvariablene er uavhengige, noe som ikke alltid er tilfelle.

Før vi går videre inn på å forklare hvordan Naive bayes fungerer, la oss sørge for at vi forstår følgende:

Betinget sannsynlighet

Naiv Bayes-algoritme er basert på Bayes-teoremet som er basert på betinget sannsynlighet: det er sannsynligheten for forekomsten av en hendelse A gitt at en hendelse B allerede har skjedd.

Eksempel:

La oss ha to krukker som inneholder fargede kuler:

Krukke 1 har 3 blå kuler, 2 røde kuler og 4 grønne kuler.
Krukke 2 har 1 blå kule, 4 røde kuler og 3 grønne kuler.

Vi ønsker å beregne sannsynligheten for å tilfeldig velge en blå ball fra en av glassene

Det er ikke annet enn summen av sannsynlighetene for å velge en blå ball fra Jar1 eller Jar2.

Nå ønsker vi å beregne sannsynligheten for å velge en blå ball gitt at vi valgte Jar1:

Til slutt ønsker vi å beregne sannsynligheten for å velge Jar1 gitt at vi tegnet en blå ball. Her bruker vi Bayes-teoremet som er angitt som følgende:

Naiv Bayes-klassifisering

I Naive Bayes klassifikatoren ønsker vi å finne klassen som maksimerer den betingede sannsynligheten gitt inngangsvektoren X; dermed kan Naive Bayes formuleres som følger:

Med bruk av Bayes-teorem blir funksjonen:

I denne formuleringen er det lett å beregne P(Ci) som ikke er noe annet enn sannsynligheten for klassen Ci, og det er lett å beregne P(x) som er sannsynligheten for at hendelsen x inntreffer.

Det som er vanskelig å beregne er P(x|Ci); sannsynligheten for hendelsen x gitt klassen Ci. For å forenkle dette ytterligere, må vi anta at alle inngangsvariablene er uavhengige; dermed kan vi skrive:

Og det er faktisk på grunn av denne antakelsen at vi kaller denne klassifikatoren "Naiv", fordi vi ikke alltid kan garantere uavhengigheten til inngangsvariablene. Den naive Bayes-klassifisereren blir:

Faktisk kan vi forenkle denne formuleringen ytterligere ved å eliminere P(x), fordi den er lik for alle klasser:

La oss nå se på et eksempel:

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

Her har vi et lite datasett som inneholder 3 inngangsvariabler: Vær, klokkeslett og ukedag, og en målvariabel: "Middag" som indikerer om en person lager mat eller bestiller middagen sin. Vi ønsker å finne klassen for inngangen x={Klart, Kveld, Helg}:

Vi må beregne den betingede sannsynligheten for klassen "Kokker" og klassen "Ordre" gitt inndata x={Klart, Kveld, Helg}. Den predikerte klassen er den som har høyest betinget sannsynlighet.

Vi starter med å beregne den betingede sannsynligheten for klassen "Kokker":

Nå beregner vi hver betinget sannsynlighet for seg:

Sannsynligheten for vær = "Klar" gitt at klassen er "Kokker" er antallet linjene med vær "Klar" og klassen "Kokk" over det totale antallet linjer med klassen "Kokker"

Det samme gjelder de andre betingede sannsynlighetene:

Nå for sannsynligheten P(Kokker) er det antall linjer med klassen "Koker" over det totale antallet linjer:

Nå beregner vi produktet av disse sannsynlighetene:

Det var for klassen "Kokker", nå må vi gjøre det samme for klassen "Bestillinger":

Vi beregner de individuelle sannsynlighetene:

Og til slutt beregner vi produktet av sannsynlighetene:

Til slutt tar vi klassen med høyest sannsynlighet som er klassen "Kokker":

Fordeler og begrensninger med denne algoritmen

Fordeler:

– Det er en veldig rask klassifisering.

– Det er enkelt å gjennomføre.

Det er ingen treningsfase, men det er bare slutninger.
Det krever ikke mye data for å trekke slutninger.

Begrensninger:

– Naive Bayes antar at inngangsvariablene er uavhengige, noe som ikke alltid stemmer.

Naive Bayes lider av nullfrekvensproblemet: det er når den tildeler null sannsynlighet til en inngangsvariabel. Dette vil nullstille all den betingede sannsynligheten P(C|x). Et triks for å unngå dette er å bruke en minimal frekvens på 1 ( i stedet for 0 ) til alle variabler.

Trening

Her er datarammen til det samme datasettet som vi har sett i eksemplet.

Din oppgave er å implementere Naive Bayes selv ved å bruke 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