Inleiding tot die Naïewe Bayes-algoritme

Tabel:

Inleiding

Naive Bayes is 'n klassifikasiemasjienleeralgoritme wat op die Bayes-stelling gebaseer is. Dit is baie doeltreffend, veral wanneer dit met tekstuele data soos: Sentimentanalise, Spam-opsporing en teksklassifikasie hanteer word.

Hierdie algoritme word "Naïef" genoem vanweë die aanname dat al die datastelveranderlikes onafhanklik is, wat nie altyd die geval is nie.

Voordat ons verder gaan om te verduidelik hoe Naive bayes werk, laat ons seker maak dat ons die volgende verstaan:

Voorwaardelike waarskynlikheid

Naïewe Bayes-algoritme is gebaseer op die Bayes-stelling wat gegrond is op voorwaardelike waarskynlikheid: dit is die waarskynlikheid van die voorkoms van 'n gebeurtenis A gegewe dat 'n gebeurtenis B reeds plaasgevind het.

Voorbeeld:

Kom ons het twee flesse wat gekleurde balle bevat:

Kruik 1 het 3 blou balle, 2 rooi balle en 4 groen balle.
Kruik 2 het 1 blou bal, 4 rooi balle en 3 groen balle.

Ons wil die waarskynlikheid bereken om 'n blou bal lukraak uit een van die flesse te kies

Dit is niks anders as die som van die waarskynlikhede om 'n blou bal uit Jar1 of Jar2 te kies nie.

Nou wil ons die waarskynlikheid bereken om 'n blou bal te kies, aangesien ons Jar1 gekies het:

Ten slotte wil ons die waarskynlikheid bereken om Jar1 te kies, aangesien ons 'n blou bal geteken het. Hier gebruik ons die Bayes-stelling wat as die volgende gestel word:

Naïewe Bayes-klassifikasie

In Naive Bayes klassifiseerder wil ons die klas vind wat die voorwaardelike waarskynlikheid maksimeer gegewe die insetvektor X; dus kan Naïewe Bayes soos volg geformuleer word:

Met die gebruik van die Bayes-stelling word die funksie:

In hierdie formulering is dit maklik om P(Ci) te bereken wat niks anders is as die waarskynlikheid van die klas Ci nie, en dit is maklik om P(x) te bereken wat die waarskynlikheid is dat die gebeurtenis x sal plaasvind.

Wat moeilik is om te bereken, is P(x|Ci); die waarskynlikheid van die gebeurtenis x gegee die klas Ci. Om dit verder te vereenvoudig, moet ons aanvaar dat al die insetveranderlikes onafhanklik is; dus kan ons skryf:

En dit is eintlik as gevolg van hierdie aanname dat ons hierdie klassifiseerder "Naïef" noem, want ons kan nie altyd die onafhanklikheid van die insetveranderlikes waarborg nie. Die Naïewe Bayes-klassifiseerder word:

Trouens, ons kan hierdie formulering verder vereenvoudig deur P(x) uit te skakel, want dit is dieselfde vir alle klasse:

Kom ons kyk nou na 'n voorbeeld:

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

Hier het ons 'n klein datastel wat 3 invoerveranderlikes bevat: Weer, Tyd en Dag van die week, en een Teikenveranderlike: "Aandete" wat aandui of 'n persoon kook of sy aandete bestel. Ons wil graag die klas van die invoer vind x={Clear, Evening, Weekend}:

Ons moet die voorwaardelike waarskynlikheid vir die klas “Kokke” en die klas “Bestellings” bereken, gegee die invoer x={Duidelik, Aand, Naweek}. Die voorspelde klas is die een wat die hoogste voorwaardelike waarskynlikheid het.

Ons begin deur die voorwaardelike waarskynlikheid van die klas "Kokke" te bereken:

Nou bereken ons elke voorwaardelike waarskynlikheid op sy eie:

Die waarskynlikheid van weer = "Clear" gegee dat die klas "Kokke" is, is die aantal reëls met weer "Clear" en klas "Kokke" oor die totale aantal reëls met klas "Kokke"

Dieselfde geld vir die ander voorwaardelike waarskynlikhede:

Nou vir die waarskynlikheid P(Kokke) is dit die aantal reëls met klas “Kokke” oor die totale aantal reëls:

Nou bereken ons die produk van hierdie waarskynlikhede:

Dit was vir die klas "Kokke", nou moet ons dieselfde doen vir die klas "Bestellings":

Ons bereken die individuele waarskynlikhede:

En ons bereken uiteindelik die produk van die waarskynlikhede:

Laastens neem ons die klas met die hoogste waarskynlikheid wat die klas "Kokke" is:

Voordele en beperkings van hierdie algoritme

Voordele:

Dit is 'n baie vinnige klassifiseerder.
Dit is maklik om te implementeer.
Daar is geen opleidingsfase nie, maar dit is slegs afleiding.
Dit verg nie baie data om afleidings te maak nie.

Beperkings:

Naïef Bayes neem aan dat die insetveranderlikes onafhanklik is, wat nie altyd waar is nie.

Naïef Bayes ly aan die nulfrekwensieprobleem: dit is wanneer dit nulwaarskynlikheid aan 'n insetveranderlike toeken. Dit sal al die voorwaardelike waarskynlikheid P(C|x) nul. Een truuk om dit te vermy, is om 'n minimale frekwensie van 1 (in plaas van 0) vir alle veranderlikes te gebruik.

Oefening

Hier is die dataraamwerk van dieselfde datastel wat ons in die voorbeeld gesien het.

Jou taak is om Naive Bayes self te implementeer deur python te gebruik:

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

Oplossing


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