Panimula sa Naive Bayes Algorithm

Talahanayan:

Intro

Ang Naive Bayes ay isang classification machine learning algorithm na batay sa Bayes theorem. Ito ay napakahusay lalo na kapag nakikitungo sa data ng teksto tulad ng: Pagsusuri ng Sentimento, Pagtukoy sa Spam at pag-uuri ng teksto.

Ang algorithm na ito ay tinatawag na "Naive" dahil sa pagpapalagay na ang lahat ng mga variable ng dataset ay independyente, na hindi palaging nangyayari.

Bago magpatuloy sa pagpapaliwanag kung paano gumagana ang Naive bayes, siguraduhin nating nauunawaan natin ang sumusunod:

May kundisyon na posibilidad

Ang algorithm ng Naive Bayes ay nakabatay sa Bayes theorem na nakabatay sa conditional probability: ito ang probabilidad ng paglitaw ng isang event A na ibinigay na ang isang event B ay naganap na.

Halimbawa:

Magkaroon tayo ng dalawang garapon na naglalaman ng mga bolang may kulay:

Ang Jar 1 ay may 3 asul na bola, 2 pulang bola at 4 na berdeng bola.
Ang Jar 2 ay may 1 asul na bola, 4 na pulang bola at 3 berdeng bola.

Gusto naming kalkulahin ang posibilidad ng random na pagpili ng isang asul na bola mula sa isa sa mga garapon

Ito ay walang iba kundi ang kabuuan ng mga probabilidad ng pagpili ng asul na bola mula sa Jar1 o Jar2.

Ngayon, gusto naming kalkulahin ang posibilidad ng pagpili ng isang asul na bola dahil pinili namin ang Jar1:

Sa wakas, gusto naming kalkulahin ang posibilidad ng pagpili ng Jar1 na ibinigay na iginuhit namin ang isang asul na bola. Dito ginagamit namin ang Bayes Theorem na nakasaad bilang mga sumusunod:

Pag-uuri ng Naive Bayes

Sa Naive Bayes classifier, gusto naming hanapin ang klase na nagpapalaki sa conditional probability na ibinigay sa input vector X; kaya, ang Naive Bayes ay maaaring mabuo bilang sumusunod:

Sa paggamit ng Bayes Theorem, ang function ay nagiging:

Sa formulation na ito, madaling kalkulahin ang P(Ci) na walang iba kundi ang probabilidad ng class Ci, at madaling kalkulahin ang P(x) na probabilidad ng kaganapang x na naganap.

Ang mahirap kalkulahin ay ang P(x|Ci); ang posibilidad ng kaganapan x na ibinigay sa klase Ci. Upang higit pang gawing simple ito, kailangan nating ipagpalagay na ang lahat ng mga variable ng input ay independyente; kaya, maaari nating isulat:

At talagang dahil sa pagpapalagay na ito na tinatawag nating "Naive" ang classifier na ito, dahil hindi natin palaging magagarantiya ang kalayaan ng mga variable ng input. Ang Naive Bayes classifier ay nagiging:

Sa katunayan, maaari pa nating gawing simple ang pormulasyon na ito sa pamamagitan ng pag-aalis ng P(x), dahil pareho ito para sa lahat ng klase:

Ngayon, tingnan natin ang isang halimbawa:

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

Dito, mayroon kaming maliit na dataset na naglalaman ng 3 input variable: Taya ng Panahon, Oras at Araw ng linggo, at isang Target na variable: "Hapunan" na nagsasaad kung ang isang tao ay nagluluto o nag-order ng kanilang hapunan . Gusto naming hanapin ang klase ng input x={Clear, Evening, Weekend}:

Kailangan nating kalkulahin ang conditional na posibilidad para sa klase na "Cooks" at ang klase na "Mga Order" na binigyan ng input na x={Clear, Evening, Weekend}. Ang hinulaang klase ay ang may pinakamataas na posibilidad na may kondisyon.

Nagsisimula kami sa pamamagitan ng pagkalkula ng kondisyon na posibilidad ng klase na "Cooks":

Ngayon kinakalkula namin ang bawat kondisyon na posibilidad sa sarili nitong:

Ang posibilidad ng lagay ng panahon="Clear" na ibinigay na ang klase ay "Cooks" ay ang bilang ng mga linya na may weather "Clear" at class na "Cooks" sa kabuuang bilang ng mga linya na may class na "Cooks"

Ang parehong napupunta para sa iba pang mga kondisyon na probabilidad:

Ngayon para sa posibilidad na P(Cooks) ito ang bilang ng mga linya na may klase na "Cooks" sa kabuuang bilang ng mga linya:

Ngayon kinakalkula namin ang produkto ng mga probabilidad na ito:

Iyon ay para sa klase na "Mga Tagapagluto", ngayon ay kailangan nating gawin ang parehong para sa klase na "Mga Order":

Kinakalkula namin ang mga indibidwal na probabilidad:

At sa wakas ay kinakalkula namin ang produkto ng mga probabilidad:

Sa wakas, kinukuha namin ang klase na may pinakamataas na posibilidad na ang klase na "Cooks":

Mga kalamangan at limitasyon ng algorithm na ito

Mga Bentahe:

Ito ay isang napakabilis na classifier.
Ito ay madaling ipatupad.
Walang yugto ng pagsasanay, ngunit ito ay hinuha lamang.
Hindi ito nangangailangan ng maraming data upang makagawa ng mga hinuha.

Mga Limitasyon:

Ipinapalagay ng Naive Bayes na ang mga variable ng input ay independyente, na hindi palaging totoo.

Ang Naive Bayes ay dumaranas ng problema sa zero-frequency: ito ay kapag nagtalaga ito ng zero probability sa isang input variable. Aalisin nito ang lahat ng conditional probability P(C|x). Ang isang trick upang maiwasan ito ay ang paggamit ng kaunting dalas ng 1 ( sa halip na 0 ) sa lahat ng mga variable.

Mag-ehersisyo

Narito ang dataframe ng parehong dataset na nakita namin sa halimbawa.

Ang iyong gawain ay ipatupad ang Naive Bayes sa iyong sarili gamit ang 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

Solusyon


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