TechCodeview

• Algoritmul Naïve Bayes este un algoritm de învățare supravegheată, care se bazează pe teorema Bayes și utilizat pentru rezolvarea problemelor de clasificare.
• Este folosit în principal în clasificarea textului care include un set de date de antrenament cu dimensiuni mari.
• Naïve Bayes Classifier este unul dintre algoritmii de clasificare simpli și eficienți, care ajută la construirea modelelor rapide de învățare automată care pot face predicții rapide.
Este un clasificator probabilistic, ceea ce înseamnă că prezice pe baza probabilității unui obiect.
• Câteva exemple populare de algoritm naiv Bayes sunt filtrarea spamului, analiza sentimentală și clasificarea articolelor .

De ce se numește Naïve Bayes?

Algoritmul Naïve Bayes este compus din două cuvinte Naïve și Bayes, care pot fi descrise astfel:

Naiv: Se numește Naiv deoarece presupune că apariția unei anumite trăsături este independentă de apariția altor trăsături. De exemplu, dacă fructul este identificat pe baza culorii, formei și gustului, atunci fructele roșii, sferice și dulci sunt recunoscute ca măr. Prin urmare, fiecare caracteristică contribuie în mod individual la identificarea faptului că este un măr fără a depinde unul de celălalt.Bayes: Se numește Bayes deoarece depinde de principiul teoremei lui Bayes .

Teorema lui Bayes:

• Teorema lui Bayes este cunoscută și ca Regula lui Bayes sau legea lui Bayes , care este folosit pentru a determina probabilitatea unei ipoteze cu cunoștințe anterioare. Depinde de probabilitatea condiționată.
• Formula pentru teorema lui Bayes este dată astfel:

Unde,

P(A|B) este probabilitatea posterioară : Probabilitatea ipotezei A asupra evenimentului B observat.

aleatoriu nu în java

P(B|A) este probabilitatea probabilității : Probabilitatea dovezilor având în vedere că probabilitatea unei ipoteze este adevărată.

P(A) este probabilitatea anterioară : Probabilitatea ipotezei înainte de observarea dovezilor.

P(B) este probabilitatea marginală : Probabilitatea dovezilor.

Funcționarea Clasificatorului lui Naïve Bayes:

Funcționarea Clasificatorului Naïve Bayes poate fi înțeleasă cu ajutorul exemplului de mai jos:

Să presupunem că avem un set de date de conditiile meteo și variabila țintă corespunzătoare ' Joaca '. Deci, folosind acest set de date, trebuie să decidem dacă ar trebui să jucăm sau nu într-o anumită zi, în funcție de condițiile meteorologice. Deci, pentru a rezolva această problemă, trebuie să urmam pașii de mai jos:

1. Convertiți setul de date dat în tabele de frecvență.
2. Generați tabelul de probabilitate prin găsirea probabilităților caracteristicilor date.
3. Acum, utilizați teorema Bayes pentru a calcula probabilitatea posterioară.

Problemă : Dacă vremea este însorită, atunci jucătorul ar trebui să joace sau nu?

Soluţie : Pentru a rezolva acest lucru, luați în considerare mai întâi setul de date de mai jos:

Tabel de frecvență pentru condițiile meteo:

Condiția meteo la tabelul de probabilități:

10 din 50

Aplicarea teoremei lui Bayes:

P(Da|Insorit)= P(Insorit|Da)*P(Da)/P(Insorit)

P(Însorit|Da)= 3/10= 0,3

P(însorit)= 0,35

P(Da)=0,71

Deci P(Da|Soare) = 0,3*0,71/0,35= 0,60

P(Nu|Insorit)= P(Insorit|Nu)*P(Nu)/P(Insorit)

P(Soare|NO)= 2/4=0,5

P(Nu)= 0,29

P(însorit)= 0,35

Deci P(Nu|Soare)= 0,5*0,29/0,35 = 0,41

Deci, după cum putem vedea din calculul de mai sus, că P(Da|Însorit)>P(Nu|Însorit)

java catch try

Prin urmare, într-o zi însorită, jucătorul poate juca jocul.

sql server pivot

Avantajele Clasificatorului Naïve Bayes:

• Naïve Bayes este unul dintre algoritmii ML rapidi și simpli pentru a prezice o clasă de seturi de date.
• Poate fi folosit atât pentru clasificări binare, cât și pentru clase multiple.
• Funcționează bine în predicțiile multiclasă în comparație cu ceilalți algoritmi.
• Este cea mai populară alegere pentru probleme de clasificare a textelor .

Dezavantajele Clasificatorului Naïve Bayes:

• Naive Bayes presupune că toate caracteristicile sunt independente sau nu au legătură, așa că nu poate învăța relația dintre caracteristici.

Aplicații ale Clasificatorului Naïve Bayes:

• Este folosit pentru Scorul de credit .
• Este folosit în clasificarea datelor medicale .
• Poate fi folosit în previziuni în timp real deoarece Naïve Bayes Classifier este un învățător dornic.
• Este folosit în clasificarea textului, cum ar fi Filtrarea spamului și Analiza sentimentelor .

Tipuri de model Bayes naiv:

Există trei tipuri de model Bayes naiv, care sunt prezentate mai jos:

gaussian: Modelul gaussian presupune că caracteristicile urmează o distribuție normală. Aceasta înseamnă că, dacă predictorii iau valori continue în loc de discrete, atunci modelul presupune că aceste valori sunt eșantionate din distribuția Gauss.Multinom: Clasificatorul Multinomial Naïve Bayes este utilizat atunci când datele sunt distribuite multinomial. Este folosit în principal pentru probleme de clasificare a documentelor, înseamnă că un anumit document aparține categoriei, cum ar fi Sport, Politică, educație etc.
Clasificatorul folosește frecvența cuvintelor pentru predictori.Bernoulli: Clasificatorul Bernoulli funcționează similar cu clasificatorul multinomial, dar variabilele predictoare sunt variabile booleene independente. De exemplu, dacă un anumit cuvânt este prezent sau nu într-un document. Acest model este renumit și pentru sarcinile de clasificare a documentelor.

Implementarea Python a algoritmului Naïve Bayes:

Acum vom implementa un algoritm naiv Bayes folosind Python. Deci, pentru aceasta, vom folosi „ datele utilizatorului ' set de date , pe care l-am folosit în celălalt model de clasificare. Prin urmare, putem compara cu ușurință modelul Naive Bayes cu celelalte modele.

Pași de implementat:

• Etapa de preprocesare a datelor
• Montarea lui Naive Bayes la setul de antrenament
• Prezicerea rezultatului testului
• Testați acuratețea rezultatului (Crearea matricei de confuzie)
• Vizualizarea rezultatului setului de testare.

1) Etapa de preprocesare a datelor:

În acest pas, vom preprocesa/pregăti datele astfel încât să le putem folosi eficient în codul nostru. Este similar cu ceea ce am făcut în pre-procesarea datelor. Codul pentru aceasta este dat mai jos:

 Importing the libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd # Importing the dataset dataset = pd.read_csv('user_data.csv') x = dataset.iloc[:, [2, 3]].values y = dataset.iloc[:, 4].values # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25, random_state = 0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() x_train = sc.fit_transform(x_train) x_test = sc.transform(x_test) 

În codul de mai sus, am încărcat setul de date în programul nostru folosind „ set de date = pd.read_csv('user_data.csv') . Setul de date încărcat este împărțit în set de antrenament și test, apoi am scalat variabila caracteristică.

Ieșirea pentru setul de date este dată astfel:

2) Montarea lui Naive Bayes la setul de antrenament:

După pasul de preprocesare, acum vom potrivi modelul Naive Bayes la setul de antrenament. Mai jos este codul pentru acesta:

 # Fitting Naive Bayes to the Training set from sklearn.naive_bayes import GaussianNB classifier = GaussianNB() classifier.fit(x_train, y_train) 

În codul de mai sus, am folosit clasificator GaussianNB pentru a-l potrivi la setul de date de antrenament. Putem folosi și alți clasificatori conform cerințelor noastre.

Ieșire:

 Out[6]: GaussianNB(priors=None, var_smoothing=1e-09) 

3) Predicția rezultatului setului de testare:

Acum vom prezice rezultatul setului de test. Pentru aceasta, vom crea o nouă variabilă predictor y_pred , și va folosi funcția de predicție pentru a face predicții.

 # Predicting the Test set results y_pred = classifier.predict(x_test) 

Ieșire:

gimp elimina filigran

Ieșirea de mai sus arată rezultatul pentru vectorul de predicție y_pred și vector real y_test. Putem vedea că unele predicții sunt diferite de valorile reale, care sunt predicțiile incorecte.

4) Crearea matricei de confuzie:

Acum vom verifica acuratețea clasificatorului Naive Bayes folosind matricea Confusion. Mai jos este codul pentru acesta:

 # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) 

Ieșire:

După cum putem vedea în rezultatul matricei de confuzie de mai sus, există 7+3=10 predicții incorecte și 65+25=90 predicții corecte.

5) Vizualizarea rezultatului setului de antrenament:

În continuare vom vizualiza rezultatul setului de antrenament folosind Nave Bayes Classifier. Mai jos este codul pentru acesta:

 # Visualising the Training set results from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Ieșire:

În rezultatul de mai sus putem vedea că clasificatorul Nave Bayes a segregat punctele de date cu granița fină. Este curba Gaussiană așa cum am folosit-o GaussianNB clasificator în codul nostru.

6) Vizualizarea rezultatului setului de testare:

 # Visualising the Test set results from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Ieșire:

Ieșirea de mai sus este rezultatul final pentru datele setului de testare. După cum putem vedea, clasificatorul a creat o curbă Gaussiană pentru a împărți variabilele „cumpărat” și „necumpărat”. Există câteva predicții greșite pe care le-am calculat în matricea de confuzie. Dar totuși este un clasificator destul de bun.