TechCodeview

• Naiv Bayes algoritm är en övervakad inlärningsalgoritm, som är baserad på Bayes teorem och används för att lösa klassificeringsproblem.
• Det används främst i textklassificering som inkluderar en högdimensionell träningsdatauppsättning.
• Naiv Bayes Classifier är en av de enkla och mest effektiva klassificeringsalgoritmerna som hjälper till att bygga de snabba maskininlärningsmodellerna som kan göra snabba förutsägelser.
Det är en probabilistisk klassificerare, vilket betyder att den förutsäger på basis av sannolikheten för ett objekt.
• Några populära exempel på Naiv Bayes Algorithm är skräppostfiltrering, sentimental analys och klassificering av artiklar .

Varför heter det Naive Bayes?

Naiv Bayes-algoritmen består av två ord Naiv och Bayes, som kan beskrivas som:

Naiv: Det kallas naivt eftersom det antar att förekomsten av en viss egenskap är oberoende av förekomsten av andra egenskaper. Som till exempel om frukten identifieras på grundval av färg, form och smak, då känns röd, sfärisk och söt frukt som ett äpple. Därför bidrar varje funktion individuellt till att identifiera att det är ett äpple utan att vara beroende av varandra.Bayes: Det kallas Bayes eftersom det beror på principen i Bayes sats .

Bayes sats:

• Bayes sats är också känd som Bayes regel eller Bayes lag , som används för att bestämma sannolikheten för en hypotes med förkunskaper. Det beror på den villkorade sannolikheten.
• Formeln för Bayes sats ges som:

Var,

P(A|B) är posterior sannolikhet : Sannolikhet för hypotes A om den observerade händelsen B.

P(B|A) är sannolikhet : Sannolikheten för bevisen givet att sannolikheten för en hypotes är sann.

P(A) är Prior Probability : Sannolikhet för hypotes innan man observerar bevisen.

P(B) är Marginal Sannolikhet : Sannolikhet för bevis.

Fungerar av Naive Bayes klassificerare:

Hur Naive Bayes klassificerare fungerar kan förstås med hjälp av exemplet nedan:

Anta att vi har en datauppsättning av väderförhållanden och motsvarande målvariabel ' Spela '. Så med hjälp av denna datauppsättning måste vi bestämma om vi ska spela eller inte en viss dag beroende på väderförhållandena. Så för att lösa detta problem måste vi följa stegen nedan:

1. Konvertera den givna datamängden till frekvenstabeller.
2. Generera sannolikhetstabell genom att hitta sannolikheterna för givna funktioner.
3. Använd nu Bayes sats för att beräkna den bakre sannolikheten.

Problem : Om vädret är soligt, bör spelaren spela eller inte?

Lösning : För att lösa detta, överväg först datauppsättningen nedan:

Frekvenstabell för väderförhållandena:

Sannolikhetstabell väderförhållanden:

Tillämpa Bayes sats:

P(Ja|Soligt)= P(Soligt|Ja)*P(Ja)/P(Soligt)

hur man får iphone emojis på Android

P(Soligt|Ja)= 3/10= 0,3

P(Soligt)= 0,35

P(Ja)=0,71

Så P(Ja|Soligt) = 0,3*0,71/0,35= 0,60

css första barn

P(No|Soligt)= P(Soligt|Nej)*P(Nej)/P(Soligt)

P(Soligt|NEJ)= 2/4=0,5

P(Nej)=0,29

P(Soligt)= 0,35

Så P(Nej|Soligt)= 0,5*0,29/0,35 = 0,41

Så som vi kan se från ovanstående beräkning att P(Ja|Soligt)>P(Nej|Soligt)

Därför kan spelaren spela spelet på en solig dag.

Fördelar med Naiv Bayes Classifier:

• Naiv Bayes är en av de snabba och enkla ML-algoritmerna för att förutsäga en klass av datamängder.
• Den kan användas för både binära klassificeringar och multiklassklassificeringar.
• Det fungerar bra i multi-class prediktioner jämfört med de andra algoritmerna.
• Det är det mest populära valet för problem med textklassificering .

Nackdelar med Naiv Bayes Classifier:

• Naiv Bayes antar att alla funktioner är oberoende eller orelaterade, så den kan inte lära sig förhållandet mellan funktioner.

Tillämpningar av Naiv Bayes Classifier:

• Den används för Kreditpoäng .
• Den används i klassificering av medicinska uppgifter .
• Den kan användas i förutsägelser i realtid eftersom Naive Bayes Classifier är en ivrig lärande.
• Det används i textklassificering som t.ex Skräppostfiltrering och Sentimentanalys .

Typer av naiva Bayes-modeller:

Det finns tre typer av naiv Bayes-modell, som ges nedan:

Gaussisk: Gaussmodellen antar att egenskaper följer en normalfördelning. Detta innebär att om prediktorer tar kontinuerliga värden istället för diskreta, så antar modellen att dessa värden samplas från den Gaussiska fördelningen.Multinomial: Multinomial Naiv Bayes klassificerare används när data är multinomial distribuerad. Det används främst för dokumentklassificeringsproblem, det betyder att ett visst dokument tillhör vilken kategori som sport, politik, utbildning, etc.
Klassificeraren använder frekvensen av ord för prediktorerna.Bernoulli: Bernoulli-klassificeraren fungerar på samma sätt som Multinomial-klassificeraren, men prediktorvariablerna är de oberoende booleska variablerna. Som om ett visst ord finns eller inte i ett dokument. Denna modell är också känd för dokumentklassificeringsuppgifter.

Python-implementering av den naiva Bayes-algoritmen:

Nu kommer vi att implementera en naiv Bayes-algoritm med Python. Så för detta kommer vi att använda ' användardata ' dataset , som vi har använt i vår andra klassificeringsmodell. Därför kan vi enkelt jämföra Naive Bayes-modellen med de andra modellerna.

Steg att implementera:

• Steg för förbehandling av data
• Passar Naive Bayes till träningssetet
• Förutsäga testresultatet
• Testa resultatets noggrannhet (Skapa förvirringsmatris)
• Visualisera testsetresultatet.

1) Steg för dataförbehandling:

I detta steg kommer vi att förbearbeta/förbereda data så att vi kan använda dem effektivt i vår kod. Det är liknande som vi gjorde i dataförbehandling . Koden för detta ges nedan:

 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) 

I koden ovan har vi laddat datamängden i vårt program med ' dataset = pd.read_csv('user_data.csv') . Den laddade datamängden är uppdelad i tränings- och testset, och sedan har vi skalat funktionsvariabeln.

pothineni bagge

Utdata för datamängden ges som:

2) Anpassa Naive Bayes till träningssetet:

Efter förbearbetningssteget kommer vi nu att anpassa Naive Bayes-modellen till träningssetet. Nedan är koden för det:

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

I ovanstående kod har vi använt GaussianNB klassificerare för att anpassa den till träningsdatauppsättningen. Vi kan också använda andra klassificerare enligt våra krav.

Produktion:

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

3) Förutsägelse av testuppsättningens resultat:

Nu kommer vi att förutsäga testsetresultatet. För detta kommer vi att skapa en ny prediktorvariabel y_pred , och kommer att använda prediktionsfunktionen för att göra förutsägelserna.

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

Produktion:

Ovanstående utdata visar resultatet för prediktionsvektor y_pred och verklig vektor y_test. Vi kan se att vissa förutsägelser skiljer sig från de verkliga värdena, som är de felaktiga förutsägelserna.

4) Skapa förvirringsmatris:

Nu ska vi kontrollera noggrannheten hos Naive Bayes-klassificeraren med hjälp av förvirringsmatrisen. Nedan är koden för det:

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

Produktion:

Som vi kan se i ovanstående förvirringsmatrisutdata finns det 7+3= 10 felaktiga förutsägelser och 65+25=90 korrekta förutsägelser.

5) Visualisera träningsuppsättningens resultat:

Därefter kommer vi att visualisera träningsuppsättningens resultat med hjälp av Na�ve Bayes Classifier. Nedan är koden för det:

 # 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() 

Produktion:

I ovanstående utdata kan vi se att Na�ve Bayes-klassificeraren har segregerat datapunkterna med den fina gränsen. Det är Gaussisk kurva som vi har använt GaussianNB klassificerare i vår kod.

6) Visualisera testsetresultatet:

 # 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() 

Produktion:

Ovanstående utgång är slutgiltig utgång för testuppsättningsdata. Som vi kan se har klassificeraren skapat en Gauss-kurva för att dela in variablerna 'köpt' och 'ej köpt'. Det finns några felaktiga förutsägelser som vi har beräknat i förvirringsmatrisen. Men det är ändå ganska bra klassificerare.