Միամիտ Բայես ալգորիթմի ներածություն

Աղյուսակ:

• Ներածություն

• Պայմանական հավանականություն

• Naive Bayes դասակարգում

• Այս ալգորիթմի առավելություններն ու սահմանափակումները

• Վարժություն

• Լուծում

Ներածություն

Naive Bayes-ը դասակարգման մեքենայական ուսուցման ալգորիթմ է, որը հիմնված է Բայեսի թեորեմի վրա: Այն շատ արդյունավետ է հատկապես այն դեպքում, երբ գործ ունենք տեքստային տվյալների հետ, ինչպիսիք են՝ զգացմունքների վերլուծությունը, սպամի հայտնաբերումը և տեքստի դասակարգումը:

Այս ալգորիթմը կոչվում է «Միամիտ» այն ենթադրության պատճառով, որ տվյալների բազայի բոլոր փոփոխականները անկախ են, ինչը միշտ չէ, որ այդպես է:

Նախքան շարունակել բացատրել, թե ինչպես է աշխատում Naive bayes-ը, եկեք համոզվենք, որ մենք հասկանում ենք հետևյալը.

Պայմանական հավանականություն

Միամիտ Բայես ալգորիթմը հիմնված է Բայեսի թեորեմի վրա, որը հիմնված է պայմանական հավանականության վրա. դա A իրադարձության առաջացման հավանականությունն է՝ հաշվի առնելով, որ B իրադարձությունն արդեն տեղի է ունեցել:

Օրինակ:

Եկեք ունենանք երկու բանկա, որոնք պարունակում են գունավոր գնդիկներ.

• Բանկա 1-ն ունի 3 կապույտ գնդակ, 2 կարմիր և 4 կանաչ գնդակ:

• Բանկա 2-ն ունի 1 կապույտ գնդակ, 4 կարմիր և 3 կանաչ գնդակ:

Մենք ուզում ենք հաշվել տարաներից մեկից պատահականորեն կապույտ գնդակ ընտրելու հավանականությունը

Դա ոչ այլ ինչ է, քան Jar1-ից կամ Jar2-ից կապույտ գնդակ ընտրելու հավանականությունների գումարը:

Այժմ մենք ցանկանում ենք հաշվարկել կապույտ գնդակ ընտրելու հավանականությունը, հաշվի առնելով, որ մենք ընտրել ենք Jar1:

Ի վերջո, մենք ուզում ենք հաշվարկել Jar1-ի ընտրության հավանականությունը, հաշվի առնելով, որ մենք կապույտ գնդակ ենք նկարել: Այստեղ մենք օգտագործում ենք Բեյսի թեորեմը, որը ասվում է հետևյալ կերպ.

Naive Bayes դասակարգում

Naive Bayes դասակարգիչում մենք ցանկանում ենք գտնել այն դասը, որը առավելագույնի է հասցնում պայմանական հավանականությունը՝ հաշվի առնելով X մուտքային վեկտորը; Այսպիսով, միամիտ Բեյսը կարող է ձևակերպվել հետևյալ կերպ.

Բեյսի թեորեմի կիրառմամբ ֆունկցիան դառնում է.

Այս ձևակերպման մեջ հեշտ է հաշվարկել P(Ci), որը ոչ այլ ինչ է, քան Ci դասի հավանականությունը, և հեշտ է հաշվարկել P(x), որը x իրադարձության հավանականությունն է։

Այն, ինչ դժվար է հաշվարկել, P(x|Ci); x իրադարձության հավանականությունը՝ հաշվի առնելով Ci դասը: Սա ավելի պարզեցնելու համար մենք պետք է ենթադրենք, որ բոլոր մուտքային փոփոխականները անկախ են. Այսպիսով, մենք կարող ենք գրել.

Եվ իրականում այս ենթադրության պատճառով է, որ մենք այս դասակարգիչին անվանում ենք «Միամիտ», քանի որ մենք միշտ չէ, որ կարող ենք երաշխավորել մուտքային փոփոխականների անկախությունը: Naive Bayes դասակարգիչը դառնում է.

Փաստորեն, մենք կարող ենք ավելի պարզեցնել այս ձևակերպումը` վերացնելով P(x), քանի որ այն նույնն է բոլոր դասերի համար.

Հիմա եկեք նայենք մի օրինակի.

| Եղանակ | Ժամանակը | Շաբաթվա օր | Ընթրիք |

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

| Մաքրել | Երեկոյան | Շաբաթ-կիրակի | Խոհարարներ |

| Ամպամած | Գիշերային | Շաբաթօրյա | Պատվերներ |

| Անձրևոտ | Գիշերային | Շաբաթօրյա | Պատվերներ |

| Անձրևոտ | Կեսօր | Շաբաթօրյա | Պատվերներ |

| Ամպամած | Կեսօր | Շաբաթ-կիրակի | Խոհարարներ |

| Մաքրել | Գիշերային | Շաբաթ-կիրակի | Խոհարարներ |

| Ձյունոտ | Երեկոյան | Շաբաթ-կիրակի | Պատվերներ |

| Մաքրել | Գիշերային | Շաբաթօրյա | Խոհարարներ |

| Մաքրել | Կեսգիշեր | Շաբաթ-կիրակի | Պատվերներ |

Այստեղ մենք ունենք փոքր տվյալների բազա, որը պարունակում է 3 մուտքային փոփոխական՝ Եղանակ, Շաբաթվա Ժամ և Օր, և մեկ Թիրախային փոփոխական՝ «Ընթրիք», որը ցույց է տալիս, թե արդյոք անձը պատրաստում կամ պատվիրում է իր ընթրիքը: Մենք ցանկանում ենք գտնել x={Clear, Evening, Weekend} մուտքագրման դասը.

Մենք պետք է հաշվարկենք «Խոհարարներ» դասի և «Պատվերներ» դասի պայմանական հավանականությունը՝ հաշվի առնելով x={Մաքուր, երեկո, շաբաթավերջ} մուտքագրումը: Կանխատեսված դասը ամենամեծ պայմանական հավանականությունն ունեցող դասն է:

Մենք սկսում ենք «Խոհարարներ» դասի պայմանական հավանականությունը հաշվարկելով.

Այժմ մենք հաշվարկում ենք յուրաքանչյուր պայմանական հավանականություն ինքնուրույն.

Եղանակի հավանականությունը=«Մաքուր»՝ հաշվի առնելով, որ դասը «Խոհարարներ» է, սա «Մաքուր» եղանակով և «Խոհարարներ» դասի տողերի թիվն է «Խոհարարներ» դասի տողերի ընդհանուր թվի նկատմամբ։

Նույնը վերաբերում է մյուս պայմանական հավանականություններին.

Այժմ P(Cooks) հավանականության համար դա «Խոհարարներ» դասի տողերի թիվն է տողերի ընդհանուր թվի նկատմամբ.

Այժմ մենք հաշվարկում ենք այս հավանականությունների արտադրյալը.

Դա «Խոհարարներ» դասի համար էր, հիմա մենք պետք է նույնը անենք «Պատվերներ» դասի համար.

Մենք հաշվարկում ենք անհատական ​​հավանականությունները.

Եվ վերջապես մենք հաշվարկում ենք հավանականությունների արտադրյալը.

Ի վերջո, մենք վերցնում ենք ամենաբարձր հավանականությամբ դասը, որը «Խոհարարներ» դասն է.

Այս ալգորիթմի առավելություններն ու սահմանափակումները

** Առավելությունները.

-Շատ արագ դասակարգիչ է։

-Հեշտ է իրականացնել։

• Մարզումների փուլ չկա, այլ միայն եզրակացություն է:

• Եզրակացություններ անելու համար շատ տվյալներ չեն պահանջվում:

Սահմանափակումներ:

• Միամիտ Բեյսը ենթադրում է, որ մուտքային փոփոխականներն անկախ են, ինչը միշտ չէ, որ ճիշտ է:

• Միամիտ Բեյսը տառապում է զրոյական հաճախականության խնդրից. դա այն է, երբ նա զրոյական հավանականություն է վերագրում մուտքային փոփոխականին: Սա կզրոյացնի բոլոր պայմանական հավանականությունը P(C|x): Սրանից խուսափելու հնարքներից մեկը 1-ի նվազագույն հաճախականությունն է (0-ի փոխարեն) բոլոր փոփոխականների համար:

Վարժություն

Ահա նույն տվյալների բազայի տվյալների շրջանակը, որը մենք տեսանք օրինակում:

Ձեր խնդիրն է ինքներդ իրականացնել Naive Bayes-ը՝ օգտագործելով 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

Լուծում

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