TechCodeview

• Het Naïve Bayes-algoritme is een begeleid leeralgoritme, dat is gebaseerd op De stelling van Bayes en gebruikt voor het oplossen van classificatieproblemen.
• Het wordt voornamelijk gebruikt bij tekst classificatie die een hoogdimensionale trainingsdataset bevat.
• Naïve Bayes Classifier is een van de eenvoudige en meest effectieve classificatie-algoritmen die helpt bij het bouwen van snelle machine learning-modellen die snelle voorspellingen kunnen doen.
Het is een probabilistische classificator, wat betekent dat het voorspelt op basis van de waarschijnlijkheid van een object.
• Enkele populaire voorbeelden van het naïeve Bayes-algoritme zijn: spamfiltratie, sentimentele analyse en classificatie van artikelen .

Waarom heet het Naïeve Bayes?

Het Naïve Bayes-algoritme bestaat uit twee woorden Naïef en Bayes, die kunnen worden omschreven als:

Naief: Het wordt naïef genoemd omdat het ervan uitgaat dat het voorkomen van een bepaald kenmerk onafhankelijk is van het voorkomen van andere kenmerken. Als de vrucht bijvoorbeeld wordt geïdentificeerd op basis van kleur, vorm en smaak, wordt rood, bolvormig en zoet fruit herkend als een appel. Daarom draagt ​​elk kenmerk afzonderlijk bij aan de identificatie dat het een appel is, zonder van elkaar afhankelijk te zijn.Bayes: Het wordt Bayes genoemd omdat het afhangt van het principe van de stelling van Bayes.

De stelling van Bayes:

• De stelling van Bayes wordt ook wel genoemd De regel van Bayes of De wet van Bayes , die wordt gebruikt om de waarschijnlijkheid van een hypothese met voorkennis te bepalen. Het hangt af van de voorwaardelijke waarschijnlijkheid.
• De formule voor de stelling van Bayes wordt gegeven als:

Waar,

P(A|B) is posterieure waarschijnlijkheid : Waarschijnlijkheid van hypothese A over de waargenomen gebeurtenis B.

P(B|A) is waarschijnlijkheidswaarschijnlijkheid : Waarschijnlijkheid van het bewijs gegeven dat de waarschijnlijkheid van een hypothese waar is.

P(A) is de voorafgaande waarschijnlijkheid : Waarschijnlijkheid van de hypothese voordat het bewijsmateriaal wordt waargenomen.

P(B) is marginale waarschijnlijkheid : Waarschijnlijkheid van bewijs.

Werking van Naive Bayes' Classifier:

De werking van Naive Bayes' Classifier kan worden begrepen met behulp van het onderstaande voorbeeld:

Stel dat we een dataset hebben van weersomstandigheden en bijbehorende doelvariabele ' Toneelstuk '. Dus met behulp van deze dataset moeten we beslissen of we op een bepaalde dag wel of niet moeten spelen, afhankelijk van de weersomstandigheden. Om dit probleem op te lossen, moeten we de onderstaande stappen volgen:

Java-generator voor willekeurige getallen

1. Converteer de gegeven dataset naar frequentietabellen.
2. Genereer een waarschijnlijkheidstabel door de kansen van bepaalde kenmerken te vinden.
3. Gebruik nu de stelling van Bayes om de posterieure waarschijnlijkheid te berekenen.

Probleem : Als het zonnig weer is, moet de speler dan spelen of niet?

Oplossing : Om dit op te lossen, moet u eerst de onderstaande dataset bekijken:

Frequentietabel voor de weersomstandigheden:

Waarschijnlijkheidstabel weersomstandigheden:

De stelling van Bayes toepassen:

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

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

P(zonnig)= 0,35

P(Ja)=0,71

Dus P(Ja|Zonnig) = 0,3*0,71/0,35= 0,60

java lang naar int

P(Nee|Zonnig)= P(Zonnig|Nee)*P(Nee)/P(Zonnig)

P(Zonnig|NEE)= 2/4=0,5

P(Nee)= 0,29

P(zonnig)= 0,35

Dus P(Nee|Zonnig)= 0,5*0,29/0,35 = 0,41

Dus zoals we uit de bovenstaande berekening kunnen zien P(Ja|Zonnig)>P(Nee|Zonnig)

Daarom kan de speler op een zonnige dag het spel spelen.

Voordelen van de Naïeve Bayes Classifier:

• Naïve Bayes is een van de snelle en gemakkelijke ML-algoritmen om een ​​klasse datasets te voorspellen.
• Het kan worden gebruikt voor binaire en multi-klasse classificaties.
• Het presteert goed in voorspellingen van meerdere klassen in vergelijking met de andere algoritmen.
• Het is de meest populaire keuze voor Problemen met tekstclassificatie .

Nadelen van de naïeve Bayes-classificator:

• Naïef Bayes gaat ervan uit dat alle kenmerken onafhankelijk of niet-gerelateerd zijn, en kan dus de relatie tussen kenmerken niet leren.

Toepassingen van Naive Bayes Classifier:

• Je gebruikt het voor Kredietscore .
• Het wordt gebruikt bij classificatie van medische gegevens .
• Het kan gebruikt worden realtime voorspellingen omdat Naive Bayes Classifier een enthousiaste leerling is.
• Het wordt gebruikt bij tekstclassificatie, zoals Spamfiltering En Sentiment analyse .

Soorten naïeve Bayes-modellen:

Er zijn drie soorten Naive Bayes-modellen, die hieronder worden weergegeven:

Gaussiaans: Het Gaussiaanse model gaat ervan uit dat kenmerken een normale verdeling volgen. Dit betekent dat als voorspellers continue waarden aannemen in plaats van discrete, het model ervan uitgaat dat deze waarden worden bemonsterd uit de Gaussiaanse verdeling.Multinomiaal: De Multinomial Naïve Bayes-classificator wordt gebruikt wanneer de gegevens multinomiaal gedistribueerd zijn. Het wordt voornamelijk gebruikt voor problemen met de classificatie van documenten, het betekent dat een bepaald document tot welke categorie behoort, zoals sport, politiek, onderwijs, enz.
De classificator gebruikt de frequentie van woorden voor de voorspellers.Bernoulli: De Bernoulli-classificator werkt vergelijkbaar met de Multinomial-classificator, maar de voorspellende variabelen zijn de onafhankelijke Booleaanse variabelen. Bijvoorbeeld of een bepaald woord wel of niet aanwezig is in een document. Dit model staat ook bekend om zijn documentclassificatietaken.

Python-implementatie van het Naive Bayes-algoritme:

Nu zullen we een naïef Bayes-algoritme implementeren met behulp van Python. Hiervoor gebruiken we dus de ' gebruikersgegevens ' gegevensset , die we in ons andere classificatiemodel hebben gebruikt. Daarom kunnen we het Naive Bayes-model gemakkelijk vergelijken met de andere modellen.

Stappen om te implementeren:

• Gegevensvoorverwerkingsstap
• Naïeve Bayes aanpassen aan de trainingsset
• Het voorspellen van het testresultaat
• Testnauwkeurigheid van het resultaat (Creation of Confusion-matrix)
• Het visualiseren van het resultaat van de testset.

1) Stap voorverwerking van gegevens:

In deze stap gaan we de gegevens voorbewerken/voorbereiden, zodat we deze efficiënt in onze code kunnen gebruiken. Het is vergelijkbaar met wat we deden bij de voorverwerking van gegevens. De code hiervoor vindt u hieronder:

 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) 

In de bovenstaande code hebben we de dataset in ons programma geladen met behulp van ' dataset = pd.read_csv('user_data.csv') . De geladen dataset is verdeeld in trainings- en testset, en vervolgens hebben we de functievariabele geschaald.

De uitvoer voor de dataset wordt gegeven als:

2) Naïeve Bayes aanpassen aan de trainingsset:

Na de voorbewerkingsstap gaan we nu het Naive Bayes-model aanpassen aan de trainingsset. Hieronder staat de code ervoor:

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

In de bovenstaande code hebben we de GaussiaanseNB-classificator om deze aan te passen aan de trainingsgegevensset. We kunnen ook andere classificaties gebruiken volgens onze vereisten.

Uitgang:

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

3) Voorspelling van het resultaat van de testset:

Nu gaan we het resultaat van de testset voorspellen. Hiervoor zullen we een nieuwe voorspellende variabele creëren y_pred , en zal de voorspellende functie gebruiken om de voorspellingen te doen.

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

Uitgang:

De bovenstaande uitvoer toont het resultaat voor de voorspellingsvector y_pred en echte vector y_test. We kunnen zien dat sommige voorspellingen verschillen van de echte waarden, wat de onjuiste voorspellingen zijn.

4) Verwarringsmatrix creëren:

Nu zullen we de nauwkeurigheid van de Naive Bayes-classificator controleren met behulp van de Confusion-matrix. Hieronder staat de code ervoor:

c++ ingesteld

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

Uitgang:

Zoals we kunnen zien in de bovenstaande verwarringsmatrixuitvoer, zijn er 7+3=10 onjuiste voorspellingen, en 65+25=90 correcte voorspellingen.

5) Visualiseren van het resultaat van de trainingsset:

Vervolgens zullen we het resultaat van de trainingsset visualiseren met behulp van Na�ve Bayes Classifier. Hieronder staat de code ervoor:

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

Uitgang:

In de bovenstaande uitvoer kunnen we zien dat de Nave Bayes-classificator de gegevenspunten heeft gescheiden met de fijne grens. Het is de Gaussische curve zoals we hebben gebruikt GaussiaansNB classifier in onze code.

6) Het resultaat van de testset visualiseren:

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

Uitgang:

De bovenstaande uitvoer is de uiteindelijke uitvoer voor testsetgegevens. Zoals we kunnen zien heeft de classificator een Gaussiaanse curve gecreëerd om de 'gekochte' en 'niet gekochte' variabelen te verdelen. Er zijn enkele verkeerde voorspellingen die we hebben berekend in de verwarringsmatrix. Maar toch is het een behoorlijk goede classificator.